Pin interrupt drain ResultResponse early-return for EXEC-INTERRUPT race

``DqliteProtocol.interrupt``'s drain loop has an explicit
``isinstance(response, ResultResponse): return`` arm to
handle the EXEC-side terminal: when an EXEC's done-callback
has emitted ``RESULT`` before the INTERRUPT took effect, the
response queue holds the RESULT before the EmptyResponse
acknowledgement. Without the arm, the loop would hit the
"Expected EmptyResponse" branch and poison the wire.

The line was uncovered. Add a unit test feeding a
``ResultResponse`` to the drain loop and asserting clean
return.

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

Author: antoineleclair

tests/test_interrupt.py

@@ -43,6 +43,26 @@ async def test_interrupt_drains_to_empty_response(self, protocol: DqliteProtocol
         # Write was issued.
         protocol._writer.write.assert_called()  # type: ignore[attr-defined]
 
+    async def test_interrupt_drains_in_flight_result_response(
+        self, protocol: DqliteProtocol
+    ) -> None:
+        """Pin the EXEC-side terminal: an INTERRUPT landing on an
+        EXEC / EXEC_SQL whose done-callback has already emitted
+        ``RESULT`` before the interrupt took effect leaves a
+        ``ResultResponse`` in the response queue ahead of the
+        ``EmptyResponse`` acknowledgement. The drain loop must
+        treat ``ResultResponse`` as equivalent to
+        ``EmptyResponse`` (wire is coherent, interrupt has been
+        honoured); without this, the "Expected EmptyResponse"
+        arm would fire and poison the wire.
+        """
+        from dqlitewire.messages import ResultResponse
+
+        result = ResultResponse(last_insert_id=42, rows_affected=1).encode()
+        protocol._reader.read = AsyncMock(side_effect=[result, b""])
+        # Must NOT raise — ResultResponse is the EXEC-side terminal.
+        await protocol.interrupt(db_id=1)
+
     async def test_interrupt_swallows_in_flight_rows(self, protocol: DqliteProtocol) -> None:
         """A RowsResponse landing after INTERRUPT (in-flight from before
         the server processed the interrupt) is dropped; the drain loop