From Python 3.7, `functools.singledispatch` makes the `register()` attribute of the generic function infer the type of the first argument automatically for functions annotated with types. That's great for DRY.
However, in 3.7 and 3.8, no check is made that the *first* parameter of the registered function is actually annotated; *any* annotation suffices, even the *return* one.

Example:
    ```
    >>> @functools.singledispatch
    ... def func(arg):...
    >>> @func.register
    ... def _int(arg) -> int:...
    >>> @func.register
    ... def _str(arg) -> str:...
```
No errors happen, although the return type, *not* `arg`, is annotated.
This results in:
    ```
    >>> func.registry
    mappingproxy({<class 'object'>: <function func>, <class 'int'>: <function _int>, <class 'str'>: <function _str>})

    ```
Obviously, that doesn't dispatch correctly.

Note that un-annotated functions *are* caught:
    ```
    >>> @func.register
    ... def _no_annotation(arg): ...
    Traceback (most recent call last):
    ...
    TypeError: Invalid first argument to `register()`: <function _no_annotation at 0x000001D769A43D30>. Use either `@register(some_class)` or plain `@register` on an annotated function.
    ```

I'm afraid my "even return" was interpreted in https://github.com/python/cpython/pull/19871 as "only return", while as stated "any annotation" suffices. To rephrase:
If the *first* parameter of the registered function isn't annotated, any non-first annotation suffices for registering, but will not dispatch correctly.
Example:
    ```
    >>> @functools.singledispatch
    ... def func(arg, x):...
    >>> @func.register
    ... def _int(arg, x:int):...
    >>> @func.register
    ... def _str(arg, x:str):...
```
No errors happen, although parameter `x` is annotated, not the first parameter `arg`. So `func()` will dispatch on the type of `arg` according to the annotation of `x`.
So I'm afraid the PR solves the specific "return" example case, but not the flagged general issue.

Right, forgot about that. We can get the first argument name from inspect.signature and then fetch it from the get_type_hints dictionary, I don't know a better way to do it.

Reproduced on 3.11.