Improve corner case handling by CommandArguments.complete()

* don't declare throwing InvalidArgumentException, catch it and wrap
with IllegalArgumentException
* throw IllegalStateException if the current argument is overriden -
it's the caller's responsibility to check it

The only way we can get InvalidArgumentException in this method is from
currentArgument(). We tell it to ignore unclosed quote, so it can't
throw it because of the unclosed quote. So it must be because of running
out of arguments. This can only happen if someone provided a cursor
outside of args, or due to a bug. That's why why we throw
IllegalArgumentException, which is a RuntimeException.

We are making the caller responsible for checking the overrides because
if the argument is overriden, they should pop it and move on to the next
argument, but we don't have a way to tell them. Returning -2 means *we*
have popped the argument(s) that was/were before the completion reques,
so they should move on without popping the argument they were just
trying to complete. So returnning -2 is not appropriate here (ok, we're
not using it in *this* method with such meaning, but others often do
`return args.complete(...)`). And assigning a different value for this
purpose, eg. -3, won't help, because the same situation applies - anyone
who does check themselves would need to check the return value anyway,
and throw something when it's -3 despite them being sure it's the right
argument.
Add CommandArguments.completeRemainingStrings()

Also:
* move a part of complete() to a new method completeRaw() which supports
completion of not-necessarily-the-current-argument, but needs the caller
to provide the raw start string
* add the argName != null condition to hasOverride and remove it from
currentArgument's override condition

popRemainingStrings() pops more than one argument/word, so it needs
custom completion method, like flags. Regular complete() won't work,
except (accidentally) for the closing quote. Add
completeRemainingStrings() as the completion method for
popRemainingStrings().

Before the change, currentArgument() checks for (argName != null &&
hasOverride(argName)). This makes it inconvinient for other methods to
check for overrides, because they have to do the null check, too. Adding
the check inside hasOverride() and removing it from currentArugment()
makes it a lot easier to check if there's an override - it's enough to
just call hasOverride().