Extract a scheduler crate from GPUI to enable unified integration testing of client and server code (#37326)

Extracts and cleans up GPUI's scheduler code into a new `scheduler`
crate, making it pluggable by external runtimes. This will enable
deterministic integration testing with cloud components by providing a
unified test scheduler across Zed and backend code. In Zed, it will
replace the existing GPUI scheduler for consistent async task management
across platforms.

## Changes

- **Core Implementation**: `TestScheduler` with seed-based
randomization, session tracking (`SessionId`), and foreground/background
task separation for reproducible testing.
- **Executors**: `ForegroundExecutor` (!Send, thread-local) and
`BackgroundExecutor` (Send, with blocking/timeout support) as
GPUI-compatible wrappers.
- **Clock and Timer**: Controllable `TestClock` and future-based `Timer`
for time-sensitive tests.
- **Testing APIs**: `once()`, `with_seed()`, and `many()` methods for
configurable test runs.
- **Dependencies**: Added `async-task`, `chrono`, `futures`, etc., with
updates to `Cargo.toml` and lock file.

## Benefits

- **Integration Testing**: Facilitates reliable async tests involving
cloud sessions, reducing flakiness via deterministic execution.
- **Pluggability**: Trait-based design (`Scheduler`) allows easy
integration into non-GPUI runtimes while maintaining GPUI compatibility.
- **Cleanup**: Refactors GPUI scheduler logic for clarity, correctness
(no `unwrap()`, proper error handling), and extensibility.

Follows Rust guidelines; run `./script/clippy` for verification.

- [x] Define and test a core scheduler that we think can power our cloud
code and GPUI
- [ ] Replace GPUI's scheduler


Release Notes:

- N/A

---------

Co-authored-by: Antonio Scandurra <me@as-cii.com>

crates/gpui/src/platform/test/dispatcher.rs

@@ -118,7 +118,7 @@ impl TestDispatcher {
         }
 
         YieldNow {
-            count: self.state.lock().random.gen_range(0..10),
+            count: self.state.lock().random.random_range(0..10),
         }
     }
 
@@ -151,11 +151,11 @@ impl TestDispatcher {
             if deprioritized_background_len == 0 {
                 return false;
             }
-            let ix = state.random.gen_range(0..deprioritized_background_len);
+            let ix = state.random.random_range(0..deprioritized_background_len);
             main_thread = false;
             runnable = state.deprioritized_background.swap_remove(ix);
         } else {
-            main_thread = state.random.gen_ratio(
+            main_thread = state.random.random_ratio(
                 foreground_len as u32,
                 (foreground_len + background_len) as u32,
             );
@@ -170,7 +170,7 @@ impl TestDispatcher {
                     .pop_front()
                     .unwrap();
             } else {
-                let ix = state.random.gen_range(0..background_len);
+                let ix = state.random.random_range(0..background_len);
                 runnable = state.background.swap_remove(ix);
             };
         };
@@ -241,7 +241,7 @@ impl TestDispatcher {
     pub fn gen_block_on_ticks(&self) -> usize {
         let mut lock = self.state.lock();
         let block_on_ticks = lock.block_on_ticks.clone();
-        lock.random.gen_range(block_on_ticks)
+        lock.random.random_range(block_on_ticks)
     }
 }
 

crates/gpui/src/platform/windows/platform.rs

@@ -94,7 +94,11 @@ impl WindowsPlatform {
         }
         let directx_devices = DirectXDevices::new().context("Creating DirectX devices")?;
         let (main_sender, main_receiver) = flume::unbounded::<Runnable>();
-        let validation_number = rand::random::<usize>();
+        let validation_number = if usize::BITS == 64 {
+            rand::random::<u64>() as usize
+        } else {
+            rand::random::<u32>() as usize
+        };
         let raw_window_handles = Arc::new(RwLock::new(SmallVec::new()));
         let text_system = Arc::new(
             DirectWriteTextSystem::new(&directx_devices)