`deprecated_aliases()` takes one message template for its whole table,
so a module whose aliases were deprecated in different releases can't
say in each warning which version deprecated it, which is what the
deprecations guide asks for (`<old> is deprecated since vX.Y.Z. Use
<new> instead.`).

`DeprecatedAlias` is added to wrap each entry of that table: the
deprecated name, where the symbol is now, and either the version it is
deprecated since or its own message. The next commit makes
`deprecated_aliases()` take these instead of a mapping.

Where the symbol is now is given as `new_module` and `new_name`, as two
arguments instead of one `module:name` string, so there is nothing to
parse and each part can be checked on its own. At least one of them is
required: without `new_name` the symbol kept its name, and without
`new_module` it was renamed in the module defining the alias, which a
single string could not say without repeating that module's name.

`since="v1.2.0"` is the common case and gives the guide's wording, so
most entries don't have to repeat it; `message` is a full template with
`{old}` and `{new}` for anything else. Exactly one of the two is
required. The next commit removes the table-wide default, so users
can't forget to include the version. `format_message()` builds the
warning from either, inserting `since` as written instead of splicing
it into a template, so a brace in it needs no escaping.

A `message` may only use plain `{old}` and `{new}` fields, with no
attribute, index, conversion or format spec, and that is checked by
parsing it. Formatting it once with placeholder names, as the
table-wide message was checked before, can't catch the rest: whether
`{old.missing}` or `{old:{new}}` fails depends on the real names, which
are only known when the alias is reached.

The name is positional-only and the rest keyword-only, so a call reads
as `DeprecatedAlias("Decimal", new_module="decimal", since="v1.2.0")`,
which says which string is which without having to know the order.

Signed-off-by: Leandro Lucarella <luca-frequenz@llucax.com>

`deprecated_aliases()` now takes the module followed by one
`DeprecatedAlias` per alias, instead of a mapping and a single
`message` for all of them, so every alias says since which version it
is deprecated:

    __getattr__ = deprecated_aliases(
        __name__,
        DeprecatedAlias("Decimal", new_module="decimal", since="v1.2.0"),
    )

Each alias warns with its own `format_message()`: the deprecations
guide's wording for one with `since`, its own template for one with
`message`.

An alias without `new_module` is looked up in `module` itself, so a
symbol renamed in place keeps its old name too. An alias pointing at
another alias of the same module, or at itself, is a `ValueError`:
reaching it would call the same `__getattr__` again, and never stop if
the two point at each other.

Aliases passed as keyword arguments (`Decimal="decimal"`) were
considered and dropped: they would make `category` and `stacklevel`
names that can never be aliased.

Each entry already checked its own fields, so what is left to check is
about the set as a whole and fits in `deprecated_aliases()` itself,
and `_checked_aliases()` goes.

Signed-off-by: Leandro Lucarella <luca-frequenz@llucax.com>