Since these `<Plug>` mappings are mode-specific, ensure we specify the
mode in the `hasmapto()` call.

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.

Since the plugin doesn't use this mapping any more due to the
performance delay, let's remove it. Tells people that it shouldn't be
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.

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.

Don't output the mapping result in the command line when using the `G`
command.

Was handling this prevously with the `<Plug>Grappele` mapping but not
with the new one that I added in
07a75d523eadaf1027aa8bf287256602ad05f97f.