cli: make FPS test deterministic via tick_at(now)

The previous test used real wall-clock sleeps and asserted 40<fps<100,
which was flaky on virtualized macOS GitHub runners (observed ~10 fps).
Add a tick_at(Instant) entry point and rewrite the tests to drive the
meter with synthetic timestamps. Also adds a window-slide test that
the original sleep-based version could not reliably exercise.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: nicejungle

crates/glyph8-cli/src/fps.rs

@@ -18,7 +18,12 @@ impl FpsMeter {
     /// Record a tick (one rendered frame). Returns the current FPS
     /// estimate, or 0.0 if fewer than 2 ticks have been seen.
     pub fn tick(&mut self) -> f32 {
-        let now = Instant::now();
+        self.tick_at(Instant::now())
+    }
+
+    /// Like [`tick`](Self::tick), but uses the supplied instant. Lets tests
+    /// drive the meter with synthetic timestamps instead of wall-clock sleep.
+    pub fn tick_at(&mut self, now: Instant) -> f32 {
         if self.window.len() == self.capacity {
             self.window.remove(0);
         }
@@ -37,7 +42,6 @@ impl FpsMeter {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::thread::sleep;
 
     #[test]
     fn first_tick_returns_zero() {
@@ -46,16 +50,29 @@ mod tests {
     }
 
     #[test]
-    fn estimates_roughly_60fps_when_ticks_are_16ms_apart() {
+    fn estimates_60fps_when_ticks_are_16_667ms_apart() {
         let mut m = FpsMeter::new(8);
-        // 5 ticks at ~16 ms intervals should give ~60 fps.
-        m.tick();
-        for _ in 0..4 {
-            sleep(Duration::from_millis(16));
-            let _ = m.tick();
+        let t0 = Instant::now();
+        // 6 synthetic ticks exactly 1/60 s apart -> exactly 60 fps.
+        let step = Duration::from_nanos(16_666_667);
+        for i in 0..6 {
+            let _ = m.tick_at(t0 + step * i);
+        }
+        let fps = m.tick_at(t0 + step * 6);
+        assert!((fps - 60.0).abs() < 0.1, "expected ~60fps, got {fps}");
+    }
+
+    #[test]
+    fn window_slides_when_capacity_exceeded() {
+        let mut m = FpsMeter::new(3);
+        let t0 = Instant::now();
+        let step = Duration::from_millis(10);
+        // 5 ticks, capacity 3 -> only the last 3 timestamps survive,
+        // so the FPS estimate reflects the recent rate (100 fps), not the average since t0.
+        for i in 0..5 {
+            let _ = m.tick_at(t0 + step * i);
         }
-        let fps = m.tick();
-        // Allow generous tolerance for sleep jitter, but it should be in the 50–80 range.
-        assert!(fps > 40.0 && fps < 100.0, "expected ~60fps, got {}", fps);
+        let fps = m.tick_at(t0 + step * 5);
+        assert!((fps - 100.0).abs() < 0.5, "expected ~100fps, got {fps}");
     }
 }