fix: Handle race condition when close_reason() returns None

The functions `no_connect()` and `with_no_connection()` previously
used `.expect()` on `quic_connection.close_reason()`, which panics
when the connection is still alive.

This race condition occurs when:
1. A QUIC connection is established to an HTTP/3 server
2. Server sends SETTINGS frame quickly (e.g., Akamai)
3. Driver thread processes incoming streams
4. Connection cleanup is triggered simultaneously
5. close_reason() returns None (connection still alive)
6. .expect() panics: "QUIC connection is still alive on close-cast"

The fix replaces .expect() with match expressions that gracefully
return ConnectionError::LocallyClosed when close_reason() is None.

Affected: HTTP/3 client applications scanning sites protected by
Akamai and similar CDNs with fast SETTINGS responses.

Author: PQCrypta

wtransport/src/error.rs

@@ -53,10 +53,15 @@ impl ConnectionError {
     }
 
     pub(crate) fn no_connect(quic_connection: &quinn::Connection) -> Self {
-        quic_connection
-            .close_reason()
-            .expect("QUIC connection is still alive on close-cast")
-            .into()
+        match quic_connection.close_reason() {
+            Some(reason) => reason.into(),
+            None => {
+                // Connection still alive but driver reported NotConnected.
+                // This race condition can occur when driver threads are processing
+                // incoming streams while connection cleanup is triggered.
+                ConnectionError::LocallyClosed
+            }
+        }
     }
 
     pub(crate) fn local_h3_error(error_code: ErrorCode) -> Self {
@@ -116,12 +121,15 @@ pub enum ConnectingError {
 
 impl ConnectingError {
     pub(crate) fn with_no_connection(quic_connection: &quinn::Connection) -> Self {
-        ConnectingError::ConnectionError(
-            quic_connection
-                .close_reason()
-                .expect("QUIC connection is still alive on close-cast")
-                .into(),
-        )
+        ConnectingError::ConnectionError(match quic_connection.close_reason() {
+            Some(reason) => reason.into(),
+            None => {
+                // Connection still alive but error reported.
+                // This race condition can occur when driver threads are processing
+                // incoming streams while connection cleanup is triggered.
+                ConnectionError::LocallyClosed
+            }
+        })
     }
 
     pub(crate) fn with_connect_error(error: quinn::ConnectError) -> Self {