Addition
is reversible, in the physics sense.
So for example one typical quantum gate is called for physicists CNOT, or you would call it in computing a generalization of the XOR gate. We physicists would not think “Oh XOR is irreversible because A ⊕ B = B ⊕ A even when A ≠ B, so the same output can come from two different outputs.” That is just not what reversibility means to us.
Contrast this with boolean AND, which we would say is irreversible. What’s the difference? It's that we think of all of our operations as being automorphisms, they map a system back to itself. So when we are looking at CNOT/XOR, we are thinking about a system which looks like this:
(t increasing)-->
A ---.-----
\
\
B ------⊕--
and if you have the output "1, 0" from this system you can infer that the input was "1, 1". In that
automorphic sense XOR is reversible, even though given the output on wire B alone you cannot decide what A or B was.
Contrast with boolean AND, where if I give you the output "0, 0" you cannot genuinely determine whether that came from "0, 1" or "0, 0". It could have come from either place.
So the automorphism (x, y) ⇒ (x, x + y) in fact is reversible in this sense; there is an automorphism which undoes it. The weirdness that you are identifying comes from the fact that you were actually considering the automorphism (x, y) ⇒ (0, x + y), which is a composition of the addition gate above with an ERASE gate, (x) ⇒ (0). Ignore the erasure and you get a reversible process again.
You might know that AND, OR, and NOT are universal: you can write any circuit from N bits to 1 bit by enumerating all of the inputs which could set the bit to 1, using AND and NOT to build “masks” for those inputs, and then using a final big OR-gate to see if any of the masks was triggered. By de Morgan's laws, you can build an OR gate out of NOT and AND; and then it is not too hard to see that you can build both NOT and AND from NAND: so we say that “NAND is a universal boolean gate.”
To get a universal reversible system you just need to go to three bits. Two working options are the Toffoli gate “doubly controlled NOT” and the Fredkin gate “controlled swap,”
Toffoli = ([x, y, z]) => [x, y, (x && y)? z : !z]
Fredkin = ([x, y, z]) => [x, x? z : y, x? y : z]
The universality of Toffoli is very easy to see from the universality of NAND: because Toffoli(x, y, 0) is actually just (x, y, x NAND y). However the fact that you start with an “isolated” bit and then it becomes “involved” in the computation, this is where you eventually start to need to erase bits if you do not have unlimited amounts of memory. [Fredkin is a little more difficult to reason about but for example Fredkin(x, 0, y) = (x, x AND y, (NOT x) AND y) and so you can then build both an AND gate directly from this construction and a NOT gate with y=1.]