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>

scala/solutions/IO.scala

@@ -4,11 +4,17 @@ package snake
 enum Op:
   case Draw(shape: Shape)
   case RandomSeed
+  case LoadBest              // m10
+  case SaveBest(score: Int)  // m10
 
-/** What the outside world answers: `Done` for a `Draw`, `Seed(value)` for a `RandomSeed`. */
+/**
+ * What the outside world answers: `Done` for a `Draw`, `Seed(value)` for a `RandomSeed`;
+ * (m10) `Best(value)` for a `LoadBest` and `Done` for a `SaveBest`.
+ */
 enum OpResult:
   case Done
   case Seed(value: Long)
+  case Best(value: Int)
 
 /**
  * m07 io: effects as values. An IO is a plain-data description of a program; nothing runs until interpreted.
@@ -43,20 +49,31 @@ object IO:
   // An interpreter that answers a RandomSeed with anything but a Seed is broken; say so loudly.
   lazy val randomSeed: IO[Long] = effect(Op.RandomSeed).map {
     case OpResult.Seed(value) => value
-    case OpResult.Done        => throw new IllegalStateException("RandomSeed must be answered with a Seed")
+    case other                => throw new IllegalStateException(s"RandomSeed must be answered with a Seed, not $other")
   }
 
   def drawScene(scene: Scene): IO[Unit] = sequence(scene.map(draw))
 
+  // m10: the stored best score. Reading it answers a number; saving answers nothing, like a draw.
+  lazy val loadBest: IO[Int] = effect(Op.LoadBest).map {
+    case OpResult.Best(value) => value
+    case other                => throw new IllegalStateException(s"LoadBest must be answered with a Best, not $other")
+  }
+
+  def saveBest(score: Int): IO[Unit] = effect(Op.SaveBest(score)).map(_ => ())
+
   // 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.
-  def trace[A](io: IO[A], seed: Long): Traced[A] =
+  // `best` (m10) answers LoadBest, the way `seed` answers RandomSeed; it defaults to 0 so m07 calls stay valid.
+  def trace[A](io: IO[A], seed: Long, best: Int = 0): Traced[A] =
     @annotation.tailrec
     def go(io: IO[A], done: List[Op]): Traced[A] = io match
       case Pure(a) => Traced(a, done.reverse)
       case Effect(op, k) =>
         val answer = op match
-          case Op.RandomSeed => OpResult.Seed(seed)
-          case Op.Draw(_)    => OpResult.Done
+          case Op.RandomSeed  => OpResult.Seed(seed)
+          case Op.Draw(_)     => OpResult.Done
+          case Op.LoadBest    => OpResult.Best(best)
+          case Op.SaveBest(_) => OpResult.Done
         go(k(answer), op :: done)
     go(io, Nil)