Give Windows a free-space gate, and stop two tests timing the scheduler

Three release-profile failures on macOS and Windows, all found by the qa gate
on its first run. Release-profile tests on those platforms had never run
before it existed, so none of these were regressions — they had simply never
been visible.

available_space returned None on every non-unix target. That did not merely
skip a test, it skipped the GATE: a Windows user extracting a disc to a full
volume got a confusing failure part-way through instead of a clear refusal up
front, and Windows is where the GUI ships. GetDiskFreeSpaceExW is declared
directly against kernel32, matching how scsi::windows already reaches Win32
rather than pulling in a binding crate for one call. It asks for
FreeBytesAvailableToCaller, which accounts for per-user quotas — the same
question f_bavail answers on unix.

The other two asserted on wall-clock timing with no margin:

- sleep_until_halted_wakes_mid_sleep bounded the wait at 350 ms and measured
  377 ms on a loaded runner. That bound measures the scheduler, not the wake.
  What the test is for is distinguishing "woke because the flag flipped" from
  "woke because the 10 s timeout expired", and 2 s does that just as well.

- abandon_loses_to_a_close_already_committed released at 600 ms against two
  300 ms grace windows plus a 250 ms poll cadence, so the windows could expire
  first and the caller abandoned — a race, not a defect. The intervals are
  scaled up so jitter is small relative to them; the ordering under test is
  unchanged, only the margin.

src/drive/mod.rs

@@ -1406,8 +1406,18 @@ mod halt_tests {
         let r = sleep_until_halted(&flag, Duration::from_secs(10));
         assert!(matches!(r, Err(Error::Halted)));
         let waited = t0.elapsed();
-        // Flag flipped at ~150 ms; we wake within one 100 ms slice → <300 ms.
-        assert!(waited < Duration::from_millis(350), "waited {waited:?}");
+        // What this test is for: the sleep must end because the flag flipped,
+        // NOT because the 10 s timeout expired. Anything comfortably under
+        // that proves it, and the lower bound proves it did not return early
+        // for some other reason.
+        //
+        // The upper bound used to be 350 ms — flag at ~150 ms plus one 100 ms
+        // poll slice, with a little slack. That measures the SCHEDULER, not
+        // this function: a loaded CI runner took 377 ms and failed, which says
+        // nothing about whether the wake worked. Bound it well below the
+        // timeout instead, so the assertion still distinguishes the two
+        // outcomes it exists to distinguish.
+        assert!(waited < Duration::from_secs(2), "waited {waited:?}");
         assert!(waited >= Duration::from_millis(140), "waited {waited:?}");
     }