Previously, if backwards was on and point was before the first number on
the line, the start position would be set to 0 (when it gets set to
`$previous_match_start`). This means the start position wouldn't get set
to the actual start position of the first number.

We want the actual start position of that number so we can move point
only if it's on or after the current number when changing between
negative and positive numbers.

Also, the `\G` pattern didn't work on some of the `sed` tests because it
matches a number at that position. Since the position wasn't one that
was followed by the number, the regex didn't match a number, and the
increment didn't happen. We can get rid of the special handling for
start position at 0 now.

I want access to the start position of the number being operated on.
This will allow me to determine if point should be moved or not.
Refactor everything to accept an array from `incdec()`.

When `$start_position` was 0 going backwards, the `sed` test command
line failed to increment the first number in the line.

Can't figure out exactly what was wrong, but there seemed to be a
problem with using the `\G` assertion for that test case. Decided to
remove `\G` when `$start_position` position is 0 to work around the
problem. Not sure if there's a more concise solution to this that
wouldn't require me to have two separate subtitution lines.

Also simplified the substitution regular expression. It turns out I
didn't need the first capture group, and it was incorrect in matching
/[^-\d]*/ because we really wanted /(?!-?\d+)/, not either or of the
characters in the group. Completely removing it still allows everything
to work. Don't remember if I added that when I was still using the
substringing algorithm, but whatever happens, it's not necessary now.

Remove the debug prints when I was trying to work out the problem with
negative numbers and the last number in the line.

Describe why we set `$point_position` the way we do.

When the negative number is the last of two numbers, the first number
would be incremented or decremented instead of the second one. Fix this
by:

* Removing the `\b` word boundaries in the search pattern. This caused
  the match start position to not include the hyphen that designates a
  negative number (instead starting at one after the hyphen).
* Setting `$start_position` to the start position of the current match
  (`$-[0]`) on every match loop iteration. This ensures the start
  position is set to an appropriate index when the number we want to
  increment is the last one in the line. Since the condition in the loop
  depends on there being a previous match position, it wouldn't set the
  start position correctly in all cases for the last number in the line.
* Remove the special case to handle the last number in the line when
  searching backward with the cursor in the last position. That case is
  now handled directly in the loop by always setting `$start_position`.

Include "-" in the pattern that matches numbers. Wrap the pattern in
word boundaries also. This passes the test I added previously to
increment a negative number.

Commenting this out instead of removing it for the moment while I add
test cases in case I need to keep debugging.