feat(tcp-connector): bound embassy loopback tests with a wall-clock watchdog

The loopback harness polls two non-terminating embassy-net stacks in the
background, so a transport regression or a dropped crossover packet would
leave `block_on` pending until the outer CI timeout instead of failing the
test. Race the foreground/background `select` against a 20s wall-clock
watchdog that re-arms its waker each poll (so the deadline is observed even
when the stacks would otherwise park) and panics with a clear message.

Addresses review feedback on #179.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: test

aimdb-tcp-connector/tests/embassy_loopback.rs

@@ -116,9 +116,19 @@ where
     Fut: Future<Output = ()>,
     F: FnOnce(Stack<'static>, Stack<'static>) -> Fut,
 {
+    use core::future::poll_fn;
+    use core::task::Poll;
+    use std::time::{Duration, Instant};
+
     use futures::future::{join4, select, Either};
     use futures::pin_mut;
 
+    // A stuck foreground (a transport regression or a dropped crossover packet)
+    // would otherwise leave `block_on` pending forever, failing only at the outer
+    // CI timeout. Bound every test with a wall-clock watchdog so `make check`
+    // fails promptly and points at the hang instead.
+    const WATCHDOG: Duration = Duration::from_secs(20);
+
     let (server_stack, mut server_net, server_ch) = make_stack(SERVER_IP, 0x1111_2222);
     let (client_stack, mut client_net, client_ch) = make_stack(CLIENT_IP, 0x3333_4444);
 
@@ -138,9 +148,31 @@ where
     futures::executor::block_on(async {
         pin_mut!(foreground);
         pin_mut!(background);
-        match select(foreground, background).await {
-            Either::Left(_) => {}
-            Either::Right(_) => panic!("background stacks ended before the test"),
+        let session = select(foreground, background);
+        pin_mut!(session);
+
+        let deadline = Instant::now() + WATCHDOG;
+        let watchdog = poll_fn(move |cx| {
+            if Instant::now() >= deadline {
+                Poll::Ready(())
+            } else {
+                // Re-arm each poll so the executor keeps spinning and observes the
+                // deadline even if the stacks and foreground would otherwise park.
+                cx.waker().wake_by_ref();
+                Poll::Pending
+            }
+        });
+        pin_mut!(watchdog);
+
+        match select(session, watchdog).await {
+            Either::Left((Either::Left(_), _)) => {}
+            Either::Left((Either::Right(_), _)) => {
+                panic!("background stacks ended before the test")
+            }
+            Either::Right(_) => panic!(
+                "watchdog: foreground stuck for {}s (transport regression or dropped packet)",
+                WATCHDOG.as_secs()
+            ),
         }
     });
 }