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/src/IO.fs

@@ -1,6 +1,8 @@
 /// m07 io: effects as values. An `IO<'a>` is a description of a program that, when interpreted, produces an `'a`:
 ///   - `Pure a`          finished, nothing left to do
 ///   - `Effect (op, k)`  perform `op`, then continue with `k result` (which returns another IO)
+/// (m10) Two more operations, for a best score that survives a reload: `LoadBest` (answered with `Best value`, the
+/// stored best) and `SaveBest score` (answered with `Done`).
 /// Building an IO never performs anything; only an interpreter (`trace` here, `Runtime.runIO` in m09) does.
 module Snake.IO
 
@@ -10,11 +12,17 @@ open Snake.View
 type Op =
     | Draw of Shape
     | RandomSeed
+    /// (m10) Read the stored best score.
+    | LoadBest
+    /// (m10) Store `score` as the new best.
+    | SaveBest of int
 
-/// What the outside world answers: `Done` for a `Draw`, `Seed value` (an unsigned 32-bit number) for a `RandomSeed`.
+/// What the outside world answers: `Done` for a `Draw`, `Seed value` (an unsigned 32-bit number) for a `RandomSeed`;
+/// (m10) `Best value` for a `LoadBest`, `Done` for a `SaveBest`.
 type OpResult =
     | Done
     | Seed of uint32
+    | Best of int
 
 type IO<'a> =
     | Pure of 'a
@@ -50,7 +58,18 @@ let randomSeed () : IO<uint32> = failwith "TODO m07"
 /// Draw every shape of a scene in order: `sequence (List.map draw scene)`.
 let drawScene (scene: Scene) : IO<unit> = failwith "TODO m07"
 
+/// (m10) An IO that reads the stored best score and produces it (the `value` of the `Best` answer).
+/// A function of `unit`, like `randomSeed ()`; an answer other than `Best` is a broken interpreter: fail loudly.
+let loadBest () : IO<int> = failwith "TODO m10"
+
+/// (m10) An IO that stores `score` as the new best and produces `()`: built like `draw`, from `SaveBest score`.
+let saveBest (score: int) : IO<unit> = failwith "TODO m10"
+
+/// (m10) `trace` that also answers every `LoadBest` with `Best best` and every `SaveBest` with `Done`.
+let traceWith (seed: uint32) (best: int) (io: IO<'a>) : Traced<'a> = failwith "TODO m10"
+
 /// A pure interpreter for tests. Answers every `RandomSeed` with `Seed seed` and every `Draw` with `Done`.
 /// Returns the final value and the operations in the order they were executed.
 /// Implemented by recursion, with no mutation.
+/// (m10) Once `traceWith` (above) is written, `trace` becomes its "no stored best" case: `traceWith seed 0 io`.
 let trace (seed: uint32) (io: IO<'a>) : Traced<'a> = failwith "TODO m07"