feat(course): audit fixes and twelve extensions (Modules 7b, 12, 13)

Audit pass:
- Frame rule counts frames since the last move, so every step lasts
  exactly movesEvery(score) frames, also right after a speed-up
- clampTime + MAX_GAP_MS: a hidden tab no longer replays the whole gap
- Pong Restart keeps held keys
- Fact corrections (mulberry32 output coverage, Haskell IO, uniform)
- New fixture cases from a mutation analysis

Extensions (all three tracks, shared fixtures, course text):
- Turn queue (Exercise 10.6), persisted high score (10.7),
  replay viewer (10.8), play() end-to-end helper (9.5)
- Optional State (4.7) and optional Module 7b, stack-safe IO
- Module 12, property-based testing with generators, shrinking,
  invariants and a model-based oracle
- Module 13, Conway's Life with a Click event
- JS type checking via jsconfig, JSDoc and types.d.ts
- Maintainer tools: scripts/mutate.mjs, scripts/typecheck-js.sh,
  Playwright end-to-end suite (e2e/, scripts/e2e.sh)

Docs: docs/contract.md is the canonical contract; specs and build log
under docs/superpowers.

Verified: JS 728, Scala 689, F# 691 unit tests; stubs and progression
M01-M13 and M07b; 176 end-to-end tests on Chromium and WebKit.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>

fsharp/solutions/IO.fs

@@ -9,11 +9,16 @@ open Snake.View
 type Op =
     | Draw of Shape
     | RandomSeed
+    // m10: the stored best score, read and written.
+    | LoadBest
+    | SaveBest of int
 
-/// What the outside world answers: `Done` for a `Draw`, `Seed value` for a `RandomSeed`.
+/// What the outside world answers: `Done` for a `Draw` or a `SaveBest`, `Seed value` for a `RandomSeed`,
+/// `Best value` for a `LoadBest`.
 type OpResult =
     | Done
     | Seed of uint32
+    | Best of int
 
 type IO<'a> =
     | Pure of 'a
@@ -47,13 +52,24 @@ let randomSeed () : IO<uint32> =
     |> map (fun result ->
         match result with
         | Seed value -> value
-        | Done -> failwith "RandomSeed must be answered with a Seed")
+        | _ -> failwith "RandomSeed must be answered with a Seed")
 
 let drawScene (scene: Scene) : IO<unit> = sequence (List.map draw scene)
 
+// m10: the stored best score. Reading it answers a number (built like randomSeed); saving answers Done, like a draw.
+let loadBest () : IO<int> =
+    effect LoadBest
+    |> map (fun result ->
+        match result with
+        | Best value -> value
+        | _ -> failwith "LoadBest must be answered with a Best")
+
+let saveBest (score: int) : IO<unit> = effect (SaveBest score) |> map ignore
+
 // Answer each op with a canned result, collecting the ops as we go. Tail recursion: the compiler turns it
 // into a loop, so long programs cannot overflow the stack, and still nothing is mutated.
-let trace (seed: uint32) (io: IO<'a>) : Traced<'a> =
+// `best` (m10) answers LoadBest, the way `seed` answers RandomSeed.
+let traceWith (seed: uint32) (best: int) (io: IO<'a>) : Traced<'a> =
     let rec go io performed =
         match io with
         | Pure a -> { Result = a; Ops = List.rev performed }
@@ -61,8 +77,13 @@ let trace (seed: uint32) (io: IO<'a>) : Traced<'a> =
             let answer =
                 match op with
                 | RandomSeed -> Seed seed
-                | Draw _ -> Done
+                | LoadBest -> Best best
+                | Draw _
+                | SaveBest _ -> Done
 
             go (k answer) (op :: performed)
 
     go io []
+
+// The Module 7 interpreter is the "no stored best" case.
+let trace (seed: uint32) (io: IO<'a>) : Traced<'a> = traceWith seed 0 io