Introduce a small frozen dataclass pairing the protobuf
`category_specific_info` variant name (`kind`) with the leftover fields that
this client version did not translate into typed attributes.

An electrical component may carry category-specific info on the wire. Known
fields are decoded into typed attributes on the concrete component, but
anything left over — because the category is unrecognized, or because a newer
API version added fields this client doesn't know yet — was either dropped or
kept as a bare `dict` with no indication of which variant it came from. This
type gives that leftover data a documented home together with the variant name
needed to interpret it.

It is hashable like the components that will carry it. The leftover `fields`
mapping may hold arbitrary, possibly unhashable values, and folding them into
the hash — even through `repr()` — is unsafe: values that compare equal can
hash or repr differently (e.g. `1 == 1.0 == True`), which would break the
invariant that equal objects hash equally. So `fields` is excluded from the
hash and instances hash on `kind` alone, mirroring `metric_config_bounds` on
the component. Collisions between instances that share a `kind` but differ in
`fields` are then possible, but harmless and highly unlikely in practice.

A follow-up commit adopts it as the `category_specific_info` field on every
electrical component.

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

Adopt `CategorySpecificInfo | None` as the `category_specific_info` field on
`ElectricalComponent`, replacing the bare `Mapping[str, Any]` that only the
mismatched component ever populated.

The protobuf `category_specific_info` oneof is now decoded once into its `kind`
plus a dict of its fields, then each concrete component drops the fields it
translated into typed attributes (e.g. a battery's `type`), keeping the `kind`
and any leftover. The result:

* recognized components keep the variant `kind` with an empty leftover;
* `UnrecognizedElectricalComponent` now preserves the carried info instead of
  dropping it — previously the escape hatch was empty for the very class that
  needs it most;
* `MismatchedCategoryElectricalComponent` keeps the full info (nothing was
  translated), recording exactly which variant disagreed with the category;
* components carrying no variant get `None`.

Because `CategorySpecificInfo` is hashable, the field no longer needs
`hash=False` and now participates in the component hash like the other fields.

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

Replace the `{id}<{Class}>{name}` rendering with `{id}:{name}:{Class}`, and
override `__str__` on the problematic subclasses so the raw wire value
that makes them problematic stays visible in the marker:

* recognized components render as `CID42:bat1:LiIonBattery` (the name is
  always literal, so an empty name reads as `CID42::LiIonBattery`)
* `UnrecognizedBattery`/`UnrecognizedEvCharger`/`UnrecognizedInverter`
  render as `CID42:bat1:Battery:type=99` — the hardcoded base label plus
  the raw type
* `UnrecognizedElectricalComponent` renders as
  `CID42:comp1:category=999` — the raw, unrecognized category
* `MismatchedCategoryElectricalComponent` renders as
  `CID42:comp1:mismatched:category=5:kind=inverter` — the
  declared category (as its enum name) against the carried variant kind.

Each subclass overrides `__str__` in full rather than sharing a
`__str__` hook on the base: the format is a single short f-string, the
tests pin it down, and the flat overrides read better than the
indirection a hook would need.

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

`MismatchedCategoryElectricalComponent.__str__` could only show the
declared category as its raw int (`category=5`), because resolving the
name would mean using the deprecated `ElectricalComponentCategory`
wrapper enum.

Store a `category_name` alongside the raw `category`, resolved by the
converter from the protobuf enum descriptor (which is not deprecated)
with the long `ELECTRICAL_COMPONENT_CATEGORY_` prefix stripped, so
`__str__` renders the short, readable name:
`CID42:comp1:mismatched:category=BATTERY:kind=inverter`

Only the mismatched component needs it: its declared category is a
recognized value that its class name hides. Unrecognized components have
no name to show (that is what makes them unrecognized), and every other
component encodes its category in its class name.

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