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/State.fs

@@ -0,0 +1,27 @@
+/// m04 state (optional, Exercise 4.7): the general pattern behind Random. A `State<'s, 'a>` wraps a function
+/// `s -> (value, nextS)`: it reads a state, produces a value and hands on a new state. `Random<'a>` is
+/// `State<uint32, 'a>`. Nothing in the game uses this file; it is here to show that Random was one example of a bigger idea.
+module Snake.State
+
+type State<'s, 'a> = State of ('s -> 'a * 's)
+
+let run (s: 's) (State f: State<'s, 'a>) : 'a * 's = f s
+
+let pure (a: 'a) : State<'s, 'a> = State(fun s -> (a, s))
+
+let map (f: 'a -> 'b) (st: State<'s, 'a>) : State<'s, 'b> =
+    State(fun s ->
+        let a, next = run s st
+        (f a, next))
+
+let bind (f: 'a -> State<'s, 'b>) (st: State<'s, 'a>) : State<'s, 'b> =
+    State(fun s ->
+        let a, next = run s st
+        run next (f a))
+
+// A function of unit: a generic module-level value is not allowed in F#.
+let get () : State<'s, 's> = State(fun s -> (s, s))
+
+let put (s: 's) : State<'s, unit> = State(fun _ -> ((), s))
+
+let modify (f: 's -> 's) : State<'s, unit> = State(fun s -> ((), f s))