fix(client): validate blocking receive lifecycle before socket I/O

Blocking receives previously checked lifecycle only after a datagram arrived, allowing invalid operations to block or return empty success after timeout. Reuse session validation before socket access and cover connected, closed, and no-test-completed states through public APIs.

crates/irtt-client/tests/client/close.rs

@@ -1,7 +1,7 @@
 use super::*;
 
 #[test]
-fn open_fails_after_close() {
+fn operations_fail_after_local_close_without_datagrams() {
     let params = default_params();
     let server = start_fake_server(move |socket, tx| {
         let (_, peer) = recv_request(&socket, &tx);
@@ -9,10 +9,26 @@ fn open_fails_after_close() {
         socket.send_to(&reply, peer).unwrap();
         let _ = recv_request(&socket, &tx);
     });
-    let mut client = Client::connect(default_test_config(server.addr)).unwrap();
+    let mut config = default_test_config(server.addr);
+    config.socket_config.recv_timeout = Some(Duration::from_millis(50));
+    let mut client = Client::connect(config).unwrap();
     assert_open_started(client.open().unwrap());
     client.close().unwrap();
     assert!(matches!(client.open(), Err(ClientError::AlreadyClosed)));
+    let results = [
+        client.recv_once(),
+        client.recv_available(RecvBudget { max_packets: 1 }),
+    ];
+    assert!(
+        matches!(
+            results,
+            [
+                Err(ClientError::AlreadyClosed),
+                Err(ClientError::AlreadyClosed)
+            ]
+        ),
+        "unexpected receive results: {results:?}"
+    );
     server.join();
 }
 
@@ -473,6 +489,21 @@ fn close_flagged_echo_reply_emits_reply_then_closes_without_sending_close() {
     ));
     assert_eq!(events.len(), 2);
 
+    let results = [
+        client.recv_once(),
+        client.recv_available(RecvBudget { max_packets: 1 }),
+    ];
+    assert!(
+        matches!(
+            results,
+            [
+                Err(ClientError::AlreadyClosed),
+                Err(ClientError::AlreadyClosed)
+            ]
+        ),
+        "unexpected receive results: {results:?}"
+    );
+
     assert!(matches!(
         client.send_probe(),
         Err(ClientError::AlreadyClosed)

crates/irtt-client/tests/client/no_test.rs

@@ -101,14 +101,29 @@ fn send_probe_fails_after_no_test_completed() {
 }
 
 #[test]
-fn open_fails_after_no_test_completed() {
+fn operations_fail_after_no_test_completed_without_datagrams() {
     let mut config = default_test_config(SocketAddr::from(([127, 0, 0, 1], 1)));
     config.run_mode = RunMode::NoTest;
+    config.socket_config.recv_timeout = Some(Duration::from_millis(50));
     let params = default_params();
     let server = no_test_server(params, 0);
     config.server_addr = server.addr.to_string();
     let mut client = Client::connect(config).unwrap();
     assert_no_test_completed(client.open().unwrap());
     assert!(matches!(client.open(), Err(ClientError::AlreadyCompleted)));
+    let results = [
+        client.recv_once(),
+        client.recv_available(RecvBudget { max_packets: 1 }),
+    ];
+    assert!(
+        matches!(
+            results,
+            [
+                Err(ClientError::AlreadyCompleted),
+                Err(ClientError::AlreadyCompleted)
+            ]
+        ),
+        "unexpected receive results: {results:?}"
+    );
     server.join();
 }

crates/irtt-client/tests/client/open.rs

@@ -1,5 +1,31 @@
 use super::*;
 
+#[test]
+fn receive_before_open_returns_not_open_without_datagrams() {
+    let peer = std::net::UdpSocket::bind("127.0.0.1:0").unwrap();
+    let mut config = default_test_config(peer.local_addr().unwrap());
+    // Bound the old implementation's blocking receive without sending a packet.
+    config.socket_config.recv_timeout = Some(Duration::from_millis(50));
+    let mut client = Client::connect(config).unwrap();
+
+    let results = [
+        client.recv_once(),
+        client.recv_available(RecvBudget { max_packets: 1 }),
+        client.recv_available(RecvBudget { max_packets: 0 }),
+    ];
+    assert!(
+        matches!(
+            results,
+            [
+                Err(ClientError::NotOpen),
+                Err(ClientError::NotOpen),
+                Err(ClientError::NotOpen)
+            ]
+        ),
+        "unexpected receive results: {results:?}"
+    );
+}
+
 // Untrusted returned intervals must be rejected before managed scheduling,
 // even when loose negotiation permits legitimate server restrictions.
 #[test]