fix(test): tolerate transient re-acquire failure in instance_lock flake

first_acquirer_succeeds_second_fails_until_first_drops flaked in CI's
heavier all-languages job (panicked: "lock must be acquirable after
release") but never in the lighter verify job running the identical
test/code on the same runner type, and didn't reproduce locally
(30/30 isolated runs, 802/802 under the identical feature set, even
with ulimit -n cut to 10). try_acquire_named collapses any transient
open()/try_lock_exclusive IO error into the same None a genuine
"still locked" result produces, and this assertion had zero retry
tolerance for that — unlike its sibling
acquire_blocking_waits_for_release_then_succeeds, which already
budgets 200ms/2s for the same class of timing slop. Give the final
re-acquire the same tolerance instead of asserting on the first
attempt.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: Your Name

crates/calm-core/src/db/instance_lock.rs

@@ -173,7 +173,29 @@ mod tests {
         );
 
         drop(first);
-        let third = try_acquire(dir.path());
+        // A bare, single re-attempt right after `drop` has zero tolerance for
+        // anything other than the lock itself — but `try_acquire_named`
+        // collapses ANY `open()`/`try_lock_exclusive` error into the same
+        // `None` a genuine "still locked" result would produce (see its doc
+        // comment). This flaked once in CI's heavier `all-languages` job (11
+        // extra language backends + lsp-overlay, some of which spawn real
+        // LSP subprocesses) but never in the lighter `verify` job running
+        // the identical test/code on the same runner type, and couldn't be
+        // reproduced locally (30/30 in isolation, 802/802 under the
+        // identical feature set, even with `ulimit -n` cut to 10) — most
+        // likely a transient EMFILE from fd pressure elsewhere in that
+        // heavier shared test binary racing this exact instant, not the
+        // lock itself being slow to release. Retry briefly rather than
+        // asserting on the very first attempt, matching the tolerance the
+        // sibling `acquire_blocking_waits_for_release_then_succeeds` test
+        // already budgets (200ms/2s) for this same class of slop.
+        let third = (0..20).find_map(|_| {
+            let lock = try_acquire(dir.path());
+            if lock.is_none() {
+                std::thread::sleep(std::time::Duration::from_millis(25));
+            }
+            lock
+        });
         assert!(third.is_some(), "lock must be acquirable after release");
     }