feat: complete wgcloak v1 transports

tests/http3_integration.rs

@@ -180,11 +180,13 @@ async fn connect_udp_rejects_bad_secret_before_returning_session() {
     let server_task = tokio::spawn(async move {
         let incoming = server_endpoint.accept().await.unwrap();
         let quic_connection = incoming.await.unwrap();
-        Http3ServerConnection::new(quic_connection)
+        let observer = quic_connection.clone();
+        let result = Http3ServerConnection::new(quic_connection)
             .await
             .unwrap()
             .accept_connect_udp("/tunnel", &clients, 1200, Duration::from_secs(3))
-            .await
+            .await;
+        (result, observer)
     });
 
     let quic_connection = connect_client(address, client_tls).await;
@@ -206,7 +208,7 @@ async fn connect_udp_rejects_bad_secret_before_returning_session() {
         "unexpected client error: {:?}",
         client_result.as_ref().err()
     );
-    let server_result = timeout(Duration::from_secs(3), server_task)
+    let (server_result, server_connection) = timeout(Duration::from_secs(3), server_task)
         .await
         .unwrap()
         .unwrap();
@@ -215,6 +217,16 @@ async fn connect_udp_rejects_bad_secret_before_returning_session() {
         "unexpected server error: {:?}",
         server_result.as_ref().err()
     );
+    timeout(Duration::from_secs(2), async {
+        loop {
+            if server_connection.close_reason().is_some() {
+                break;
+            }
+            tokio::task::yield_now().await;
+        }
+    })
+    .await
+    .expect("authentication rejection must close the QUIC connection");
 }
 
 #[tokio::test]
@@ -268,5 +280,11 @@ async fn http3_server_admission_permit_tracks_authenticated_session_lifetime() {
     assert_eq!(admission.pending_handshakes(), 0);
     server_session.close().await.unwrap();
     assert_eq!(admission.active_sessions(), 0);
-    client_session.close(Duration::from_secs(2)).await.unwrap();
+    timeout(
+        Duration::from_secs(2),
+        client_session.close(Duration::from_millis(250)),
+    )
+    .await
+    .expect("client cleanup after peer close must be bounded")
+    .unwrap_or_else(|error| panic!("client cleanup returned an unexpected error: {error}"));
 }