This is an experimental change to an experimental subpackage.
Rather than explicitly enumerating types 3x between
- class declaration
- SUPPORTED_FIELDS dict
- init declaration

and then auto-lifting `locals()` values into assignments, take a
slightly different tack of enumerating the types twice
- class declaration with Annotated
- init declaration

And then manually assigning fields (pylint will keep us honest about
missing parameters).

A new set of validator helpers cover our needs in terms of picking up
and using the validators.

If a 'DEFAULT' sentinel value is seen in the Annotated data, then the
type from the annotation can be mapped to a known validator. Bake this
logic into the validators.

Declare a well-typed protocol for validators, which defines the
`__call__` method to take a name (for the field) and a value to
validate.

Each field validation is now done with an explicit call to a
validator, and without any derivation of validators, types, or
meta-programming.

The tow remaining items which needed special handling were:
- checking for non-null values being passed for at least one argument
- loading a data object from a dict filtering out extra params

In these two cases, the desired arg names are found by examining
`__init__` and excluding `self` and `extra`, each of which has special
meaning.

In general, the paradigm shift offered here is to be more direct and
explicit, even if the requirement is that we are verbose in the
process. Partly, this was based on the realization that many of the
meta-programming techniques being used were not resulting in the
desired level of brevity and clarity.

An aborted implementation of annotation-based validators required that
we preserve runtime typing. That constraint is gone, meaning we don't
need the relevant flag for pre-commit.

Relegate the strategy of looking at `__init__` signatures to the
testsuite. Rather than doing this at runtime, reintroduce
`SUPPORTED_FIELDS` as a property of GARE-related classes, but as a set
of strings.

The testsuite now checks the set against `__init__` for the relevant
class.
The result is more verbose but simpler.

- Deriving a value from the `locals()` of a parent frame saves us some
  redundancy and is safe so long as the relevant helper remains purely
  internal
- Inspecting an `__init__` signature is simple and easy if it is done
  in the class declaration context when `__init__` is "just a
  function" and not yet bound to the class. No complex derivation of
  the `__init__` function is therefore needed

In order for this to work, `HasSupportedFields` needs to become an
explicit Protocol, or mypy incorrectly fails some of the variants.