Recursive Definition Not The Same Thing As The Limit
There is no paradox to be found. The limit of a summation doesn't add enough terms to create a paradox. In fact, to take the limit, you have to subtract the tail of the recursion off. This is what will be demonstrated, that the value of some object $A$ can be a finite value, when the limit of a sequence that it expands to is not finite.
$$
Limit[A] = A - Tail[A]
$$
A sum of "all" powers of 2 is just a way to write -1; and you can never actually add the "last" term to cause the sum to become -1, so there is no contradiction. It's basic recursion, as found all over computer science. Focus on what a recursive definition actually says. We are defining an object $A$ with this property.
$$
A = 1 + 2A
$$
$$
(A = 1 + 2A) - 2A
$$
$$
-A = 1
$$
$A$ is an object whose recursive definition says that it has an equal value to $-1$, though it may have other representations. This is no more strange than $0.999... = 1.000$ due to the trailing 9 triggering a carry and giving them both the same value.
$$
A = -1
$$
Nothing particularly controversial happened there. But -1 is special because the sum of powers of 2 is always 1 less than the next power of 2. Just substitute equals for equals, and it stays consistent:
$$
A = (1 + 2(1 + 2(1 + 2(1 + 2A))))
$$
$$
A = 1 + 2 + 4 + 8 + 16A
$$
For every finite number of terms to expand, this recurrence is equal to $-1$ due to $A = -1$,
$$
A = (1 - 2) = (1 + 2 - 4) = (1 + 2 + 4 - 8) = \cdots
$$
So, very carefully, proceed without invoking a notion of infinity or twos complement computer representations. These are true for any finite $N$,
$$
A = 1 + 2 + 4 + 8 + \cdots + (2^N)A
$$
$$
-1 = 1 + 2 + 4 + 8 + \cdots + (2^N)(-1)
$$
$$
-1 = 1 + 2 + 4 + 8 + \cdots + (-(2^N))
$$
Write a closed form for first $N$ in the recursive definition,
$$
A = (2^N - 1) + (2^N)A
$$
$$
A = (-1 + 2^N) + (2^N)A
$$
That last term added in is the tail. $N$ can be as high or low as we like.
$$
Tail[A] = (2^N)A
$$
$A$, when defined recursively, solves for $-1$, regardless of what the limit of the sum is. So define the limit of the sequence as actually subtracting that tail off. Remember that the whole point of the integer $+\infty$ is that it isn't a number of iterations that you can perform. So no sum is in danger of yielding a result of -1. Remove the tail of the recursion off, because in a sum, we can add any number of terms, but there is no last term if you want the limit, rather than the value of $A$:
$$
Limit[A] = \lim_{N \to \infty} (A - Tail[A])
$$
Now here is the crucial part, where people that don't believe in recursion will argue with the result. $A$ is just $-1$ by definition. $A$ has a finite value. But if we subtract $Tail[A]$, we are subtracting an arbitrarily large number.
$$
Limit[A] = \lim_{N \to \infty} (-1 - (2^N)(A)) = \lim_{N \to \infty}(-1 + (2^N)) = -1 + \lim_{N \to \infty} 2^N = \infty
$$
The really important idea here is that in general, the value of the recursively defined value is not necessarily the same as the limit of any indefinitely long sequence that you can expand it to.
$$
A \not= Limit[A]
$$
Part of the problem is that the use of "$\cdots$" and "$\sum$" are not as specific as a recursive definition. There is no way to interpret recursion other than substituting equals for equals. This is why many computer languages only give you recursion as the way to define iterative constructs; because the computer cannot make "common sense" judgments, or iron out ambiguity for you.
Ambiguity Of Sum Notation With $\infty$
Currently, if somebody writes this down, I'm not sure which interpretation they mean.
$$
\sum_{N}^{0 \cdots \infty}{2^N}
$$
If they say that $L \to \infty$, then the intent is confusing:
$$
A = \sum_{n}^{0 \cdots L}{2^n}
$$
$$
\sum_{n}^{0 \cdots L}{2^n} = 1 + \sum_{n}^{1 \cdots L}{2^n} = 1 + 2\sum_{n}^{0 \cdots L}{2^n}
$$
We said this, without meaning to say it:
$$
A = 1 + 2A
$$
If $L$ is finite, then that was false, because the summations expand to exactly $1 + L$ terms being added. If $L$ is infinite, the intent was generally not to define it recursively as $A = 1 + 2A$. But it's unsettling that we are not substituting true equals for equals (stronger than being equivalent values). If we ensure that the summations add the exact same number of terms so that they are exactly equal definitions:
$$
\sum_{n}^{0 \cdots L+1}{2^n} = 1 + 2\sum_{n}^{0 \cdots L}{2^n}
$$
The above statement cannot be solved for $-1$ because they don't add the exact same number of terms (that can be as many as we want). A computer is going to need to convert equal statements to statements that are exactly equal in every way before it can perform a substitution. Being imprecise with $\infty$ makes this hard to do without human intervention.
$$
(\sum_{n}^{0 \cdots L}{2^n}) + 2^{L + 1} = 1 + 2\sum_{n}^{0 \cdots L}{2^n}
$$
$$
A_2 + 2^{L + 1} = 1 + 2 A_2
$$
This doesn't cause $A_2$ to solve for -1 now. In fact, it subtracted the tail off of the recursion:
$$
A_2 = 1 + 2 A_2 - 2^{L+1}
$$
$$
-A_2 = 1 - 2^{L+1}
$$
$$
A_2 = -1 + 2^{L+1}
$$
If you try to sit down and write code to do these algebraic manipulations, problems like this are quite obvious; because the representation has to be converted to be exact before a substitution match can be made. Even exact same statements with different side-conditions are not exactly equal for substitution purposes. You must substitute equals for equals exactly (some equivalences are not as well defined enough to perform deterministicaly by a machine).
The correspondence with 2s complement isn't accidental.
Each bit represents an added in power of 2. Even in a finite representation, "all ones in high bits" means the same thing as "no zeroes in high bits (to the left)"; meaning that it doesn't necessarily rely on a notion of infinity to work.
$$
A = -1 = 1 + 2 + 4 + 8 + \cdots = 1 + 2A
$$
This even works on the other side of the decimal point as well, where "all ones (to the right)" means the same thing as "no zeroes (to the right)" and triggers a ripple/carry just like in any finite machine representation. That is why simply negating the bits negates the number if you also represent the low bits (due to the ripple/carry).
Negate every bit above and below the decimal point for the number -1, gives you this:
$$
A_3 = 1/2 + 1/4 + 1/8 + \cdots = 1
$$
