logging: stop warning_once from crashing on unhashable kwargs like extra={...}

[c-tonneslan]

`MultiProcessAdapter.warning_once` is decorated with `@functools.lru_cache(None)`, which hashes every positional and keyword argument. The standard `logging` API accepts an `extra={...}` kwarg, but dicts aren't hashable, so a normal call like

```python
logger = get_logger(name)
logger.warning_once("only once", extra={"id": 1})
```

raises `TypeError: unhashable type: 'dict'`. Same story for any other unhashable kwarg (`stack_info=False` is fine, but `extra` is the common one).

Cache by the message text on a per-adapter set instead. That matches the docstring ("the same message only once"), accepts whatever kwargs the underlying `warning()` accepts, and as a bonus drops the implicit `self` retention that an `lru_cache(None)` on an instance method causes.

Added a regression test in `tests/test_logging.py` that calls `warning_once` with an `extra={...}` kwarg, twice with the same message and once with a different one, and asserts each unique message is emitted exactly once. The two existing logging tests still pass.

Sample crash before:

```pycon

from accelerate import Accelerator
from accelerate.logging import get_logger
Accelerator()
logger = get_logger("test")
logger.warning_once("hi", extra={"a": 1})
Traceback (most recent call last):
...
TypeError: unhashable type: 'dict'
```