Document the retry loop invariant on the final raise last_error

The `# type: ignore[misc]` on the final `raise last_error` silenced a
real mypy complaint (`last_error` is typed `Exception | None`) without
explaining why the raise is safe. The reason is a loop invariant: the
only non-`return` way out of the loop is the `break` on the final
attempt, which runs immediately after `last_error = e`, and the guard
at line 33 rejects `max_attempts < 1`. Expand the comment so the next
reader can verify the claim without tracing the function.

Also add a test that exercises the one-attempt edge case — `range(1)`
is the boundary where the loop body must set `last_error` and
immediately break on the first iteration.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/dqliteclient/retry.py

@@ -53,4 +53,7 @@ async def retry_with_backoff[T](
 
             await asyncio.sleep(delay)
 
+    # last_error is non-None here: the break on the final attempt only
+    # runs after ``last_error = e`` executes, and max_attempts < 1 is
+    # rejected above. mypy can't see the loop invariant.
     raise last_error  # type: ignore[misc]

tests/test_retry.py

@@ -47,6 +47,23 @@ async def always_fail() -> str:
 
         assert call_count == 3
 
+    async def test_max_attempts_one_raises_on_first_failure(self) -> None:
+        """Edge case: with ``max_attempts=1`` the loop breaks on its first
+        iteration. Covers the ``if attempt == max_attempts - 1: break``
+        path that the final ``raise last_error`` relies on.
+        """
+        call_count = 0
+
+        async def fail_once() -> str:
+            nonlocal call_count
+            call_count += 1
+            raise ValueError("fail")
+
+        with pytest.raises(ValueError, match="fail"):
+            await retry_with_backoff(fail_once, max_attempts=1, base_delay=0.01)
+
+        assert call_count == 1
+
     async def test_max_attempts_zero_raises_value_error(self) -> None:
         async def should_not_be_called() -> str:
             raise AssertionError("Should not be called with max_attempts=0")