test(iroh): Fix test_active_relay_inactive test being flaky (#3680)

## Description

This reverts a change from this PR:
#3384

I originally thought I could make this test more reliable by pausing the
tokio time across the `tokio::time::timeout` calls, but it turns out
that actually makes the test *more* flaky:
- When time is paused, the timeout will immediately fire once the tokio
runtime has no more CPU work to do.
- It's possible that there's no CPU work to do anymore, while there's
something else that is actually still doing work, e.g. networking.
- Before the `ActiveRelayActor` finishes its `run_connected` loop, it
will call `client_sink.close().await`, which will do actual I/O. When
the tokio runtime is paused at that moment, it'll immediately trigger
the test's timeout.

## Notes & open questions

I couldn't reproduce this problem even across a couple thousand runs of
the test locally. I'm not super confident that this fixes things, but
I've analyzed the logs and this seems to be the most likely thing that's
happening to me.

Closes #3613 

## Change checklist
<!-- Remove any that are not relevant. -->
- [x] Self-review.

Author: matheus23

iroh/src/magicsock/transports/relay/actor.rs

@@ -1459,7 +1459,6 @@ mod tests {
 
     #[tokio::test]
     #[traced_test]
-    #[ignore = "flaky"]
     async fn test_active_relay_inactive() -> Result {
         let (_relay_map, relay_url, _server) = test_utils::run_relay_server().await?;
 
@@ -1481,11 +1480,11 @@ mod tests {
         );
 
         // Wait until the actor is connected to the relay server.
-        tokio::time::timeout(Duration::from_millis(200), async {
+        tokio::time::timeout(Duration::from_secs(5), async {
             loop {
                 let (tx, rx) = oneshot::channel();
                 inbox_tx.send(ActiveRelayMessage::PingServer(tx)).await.ok();
-                if tokio::time::timeout(Duration::from_millis(100), rx)
+                if tokio::time::timeout(Duration::from_millis(200), rx)
                     .await
                     .map(|resp| resp.is_ok())
                     .unwrap_or_default()
@@ -1497,12 +1496,12 @@ mod tests {
         .await
         .std_context("timeout")?;
 
-        // From now on, we pause time
-        tokio::time::pause();
         // We now have an idling ActiveRelayActor.  If we advance time just a little it
         // should stay alive.
         info!("Stepping time forwards by RELAY_INACTIVE_CLEANUP_TIME / 2");
+        tokio::time::pause();
         tokio::time::advance(RELAY_INACTIVE_CLEANUP_TIME / 2).await;
+        tokio::time::resume();
 
         assert!(
             tokio::time::timeout(Duration::from_millis(100), &mut task)
@@ -1513,15 +1512,20 @@ mod tests {
 
         // If we advance time a lot it should finish.
         info!("Stepping time forwards by RELAY_INACTIVE_CLEANUP_TIME");
+        tokio::time::pause();
         tokio::time::advance(RELAY_INACTIVE_CLEANUP_TIME).await;
+        tokio::time::resume();
+
+        // We resume time for these timeouts, as there's actual I/O happening,
+        // for example closing the TCP stream, so we actually need the tokio
+        // runtime to idle a bit while the kernel is doing its thing.
         assert!(
-            tokio::time::timeout(Duration::from_millis(1000), task)
+            tokio::time::timeout(Duration::from_secs(1), task)
                 .await
                 .is_ok(),
             "actor task still running"
         );
 
-        tokio::time::resume();
         cancel_token.cancel();
         Ok(())
     }