Previously, if you typed, for example:

    dgGk

this would perform `dk`, deleting the current line and the one above it.
That doesn't really make any sense. Instead, the `gG` should cancel the
operator. Do this by mapping to `<C-c>`.

In normal and visual modes, `gG` would move the cursor to the 0th
column. Returning an empty {rhs} causes the cursor to stay in the same
position it was in before pressing `gG`.

Now that this is an `<expr>` mapping, we don't need any special handling
for visual mode as this will be taken care of automatically.

Remove the `mode` argument as it's no longer used.

This function no longer needs any extra arguments.

Fix visual mode bug where when the cursor is at the top of a visual
selection, pressing `gG` changes the bottom of the visual selection
instead of the top.

Holdover from old code.

Clean up the file by removing old code that's no longer necessary.

Previously, if we stored a number in `s:line`, for example with `17G`,
then `>gG` would cause lines .,17 to be indented 17 times due to the use
of `V`.

When I removed `V` from the omap, any commands using `gG` operated
characterwise, when they should operate linewise.

Found this answer from Liu Sha
(https://stackoverflow.com/users/7026980/liu-sha)
https://stackoverflow.com/questions/4261177/discarding-count-in-expr-mappings/53182922#53182922
that shows how to discard the count for different types of mappings:

> nnoremap <expr> s "@_" . ToNthSpace()
> vnoremap <expr> s "@_" . ToNthSpace()
> onoremap <expr> s printf(":normal %s\<cr>", ToNthSpace())

The `:normal!` looks like it discards the count, so this gives us what
we want. Adapted the suggestion into a new `<expr>` omap that indents
only once for e.g. .,17.

gG omap works characterwise but should work linewise.
Adding V to the gG omap causes >17G to indent 17 times instead of once.

Try changing `G` to an `<expr>` mapping to simplify the code, allowing
it to work more exactly like the normal `G`. This resulted in moving the
logic to `grappele#Recall()`, causing problems for `gG`.

I previously added o- and v-maps for the `gG` mapping, but hadn't done
so for `G`.

This change allows us to reuse lines given to `G` from other modes. For
example:

    173>>..ygG

Didn't use `<Plug>` mappings here because after testing them, there was
a noticeable delay. Found 07a75d523eadaf1027aa8bf287256602ad05f97f,
which describes a performance penalty, so used direct mappings instead.

Kept the `<Plug>Grappele` mapping for a measure of backward
compatibility.

New mappings that allow the stored `G` position to be used in both
visual mode and operator-pending mode for greater flexibility.