asyncio: detect cross-instance reentrant deadlocks before the poll loop

[HrachShah]

Summary

BaseAsyncFileLock.acquire is missing the per-thread cross-instance deadlock check that BaseFileLock.acquire has. The sync path looks up the canonical lock path in the thread-local _registry and raises RuntimeError("Deadlock: ...") when a different instance is already holding the same path on the same thread; the async path skips that step, so two distinct AsyncFileLock (or AsyncSoftFileLock) objects constructed against the same path from the same task enter the poll loop and the second one blocks forever in flock() / os.open instead of failing fast.

This PR mirrors the sync flow inside async acquire():

1. After lock_counter += 1, compute the canonical path and look up the existing holder. If a different instance is the holder and the caller asked for indefinite blocking (timeout<0), raise the same RuntimeError before the poll starts. Same finite/non-blocking exceptions (Timeout) still apply when timeout >= 0 or blocking is False, matching the sync precedence.
2. On the polling exception path, mirror the sync _registry.held.pop on lock_counter == 0 so a failed acquire cleans its would-be entry.
3. On success, write self's id into the registry when lock_counter reaches 1, so a future cross-instance acquire on the same path can find it.
4. On release, pop the registry entry the same way the sync release() does — without this the stale id would linger and confuse the next cross-instance acquire.

The thread-local scope of _registry fits the asyncio model where one task typically runs on one thread; concurrent tasks on the same thread that legitimately want the same path with finite timeout are still governed by the existing _check_give_up / Timeout path and are not false-positives because would_block requires timeout < 0.

Reproduction

import asyncio, tempfile
from pathlib import Path
from filelock import AsyncFileLock

async def main():
    with tempfile.TemporaryDirectory() as d:
        lock1 = AsyncFileLock(str(Path(d) / 'a'))
        lock2 = AsyncFileLock(str(Path(d) / 'a'))  # same canonical path
        async with lock1:
            await lock2.acquire()  # hangs forever on unfixed code

asyncio.run(main())

After the fix, lock2.acquire() raises RuntimeError('Deadlock: ...') immediately, with the same message and recovery hint as the sync path ("Use is_singleton=True to enable reentrant locking across instances").

Tests

New file tests/test_async_self_deadlock.py mirrors the existing sync test_self_deadlock.py cases for the async path: same-task different-instance raises, finite timeout still raises Timeout, non-blocking still raises Timeout, different paths no conflict, same instance reentrant, is_singleton=True short-circuits, different tasks no false positive, symlink to same canonical path, cleanup on release, force release clears registry. 20 cases total. The two cross-instance and two symlink cases hang indefinitely on the unfixed code; the other 16 already pass.

$ python3 -m pytest tests/test_async_self_deadlock.py -v
============================== 20 passed in 0.41s ==============================
$ python3 -m pytest tests/ --deselect tests/test_filelock.py::test_stale_inode_retry_on_unlinked_lock
===== 509 passed, 33 skipped, 1 deselected, 6 warnings in 82.51s =====

(The single deselected test is a pre-existing flake on the unfixed main; it does not touch the changed code.)

ruff check and ruff format --check are both clean on the modified files. mypy reports the same 6 pre-existing errors in asyncio.py; no new ones.