fix: catch BaseException in connect() to clean up on CancelledError

The `except Exception:` handler in connect() did not catch
CancelledError (a BaseException since Python 3.9). If a task was
cancelled during handshake() or open_database(), the protocol's
close() was never called, leaking the TCP socket. The connection
also appeared as "connected" despite being half-initialized.

Change to `except BaseException:` so cancellation properly closes
the transport and resets the protocol to None.

Closes #083

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

Author: antoineleclair

src/dqliteclient/connection.py

@@ -101,7 +101,7 @@ async def connect(self) -> None:
         try:
             await self._protocol.handshake()
             self._db_id = await self._protocol.open_database(self._database)
-        except Exception:
+        except BaseException:
             self._protocol.close()
             self._protocol = None
             raise

tests/test_connection.py

@@ -493,6 +493,45 @@ async def cancelled_transaction():
         # _in_transaction must be cleaned up
         assert not conn._in_transaction
 
+    async def test_connect_cancellation_cleans_up_protocol(self) -> None:
+        """Cancelling connect() during handshake must close the transport."""
+        import asyncio
+
+        conn = DqliteConnection("localhost:9001")
+
+        mock_reader = AsyncMock()
+        mock_writer = MagicMock()
+        mock_writer.drain = AsyncMock()
+        mock_writer.close = MagicMock()
+        mock_writer.wait_closed = AsyncMock()
+
+        handshake_entered = asyncio.Event()
+
+        async def slow_handshake(*args, **kwargs):
+            handshake_entered.set()
+            await asyncio.sleep(10)  # Will be cancelled
+
+        with (
+            patch("asyncio.open_connection", return_value=(mock_reader, mock_writer)),
+            patch("dqliteclient.connection.DqliteProtocol") as MockProto,
+        ):
+            proto_instance = MagicMock()
+            proto_instance.handshake = AsyncMock(side_effect=slow_handshake)
+            proto_instance.close = MagicMock()
+            MockProto.return_value = proto_instance
+
+            task = asyncio.create_task(conn.connect())
+            await handshake_entered.wait()
+            task.cancel()
+
+            with pytest.raises(asyncio.CancelledError):
+                await task
+
+        # The protocol must have been closed to avoid socket leak
+        proto_instance.close.assert_called()
+        # The connection must not appear as connected
+        assert not conn.is_connected
+
     async def test_not_leader_error_invalidates_connection(self) -> None:
         """OperationalError with 'not leader' code should invalidate the connection."""
         conn = DqliteConnection("localhost:9001")