test(lsp): tolerate slow recovery cold-start in cancel-refresh test (#255)

`broker_cancels_partial_refresh_without_poisoning_warm_client` asserts
that aborting a partial refresh does not poison the broker: a subsequent
refresh must spin up a clean client. On a loaded macOS CI runner the
recovery client's `python3` cold-start intermittently exceeds the 3s
initialize floor, surfacing a transient "initialize timed out" — a slow
start, not a poisoned broker — which failed the test on two consecutive
unrelated PRs (#253, #254).

Retry the recovery refresh a bounded number of times (5, 50ms apart),
tolerating only the transient initialize-timeout error and still failing
fast on any other error. The Ready/total_errors assertions are unchanged.

Co-authored-by: Claude <noreply@anthropic.com>

Author: ScriptedAlchemy

tests/hooks_lsp_suite/lsp_code_diagnostics_test.rs

@@ -598,13 +598,37 @@ async fn broker_cancels_partial_refresh_without_poisoning_warm_client() {
     let _ = handle.await;
 
     std::fs::write(&script_path, fake_lsp_script()).unwrap();
-    broker
-        .refresh_documents(
-            FAKE_LANGUAGE,
-            vec![fake_document(FAKE_LANGUAGE, FAKE_PATH, "let nope")],
-            FAKE_LSP_TIMEOUT,
-        )
-        .await
+    // The property under test is that aborting a partial refresh does not
+    // poison the broker: a *subsequent* refresh must spin up a clean client.
+    // On a loaded CI runner the recovery client's `python3` cold-start can
+    // exceed the initialize floor and surface a transient "initialize timed
+    // out" — that is a slow start, not a poisoned broker — so retry the
+    // recovery a bounded number of times before asserting.
+    let mut recovery = None;
+    for attempt in 0..5 {
+        let result = broker
+            .refresh_documents(
+                FAKE_LANGUAGE,
+                vec![fake_document(FAKE_LANGUAGE, FAKE_PATH, "let nope")],
+                FAKE_LSP_TIMEOUT,
+            )
+            .await;
+        match &result {
+            Ok(()) => {
+                recovery = Some(result);
+                break;
+            }
+            Err(err) if err.to_string().contains("initialize timed out") => {
+                recovery = Some(result);
+                if attempt + 1 < 5 {
+                    tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+                }
+            }
+            Err(err) => panic!("recovery refresh failed unexpectedly: {err}"),
+        }
+    }
+    recovery
+        .expect("recovery refresh should have been attempted")
         .expect("next refresh should start a clean client and recover");
 
     let snapshot = broker.snapshot();