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/web/BrowserPlatform.scala

@@ -4,9 +4,12 @@ package web
 import scala.scalajs.js
 import scala.scalajs.js.Dynamic.global
 import scala.scalajs.js.typedarray.Uint32Array
+import scala.util.control.NonFatal
 
 /**
  * Browser glue: turns a canvas into a Platform. Impure by nature; not part of the exercises' logic.
+ * Snake, Pong, the replay viewer and Life share it; only Snake performs `LoadBest` and `SaveBest`, so only Snake
+ * touches storage, and only Life does anything with clicks.
  * `js.Dynamic` lets us call browser APIs by name without type facades (and without extra libraries).
  */
 final class BrowserPlatform(canvas: js.Dynamic) extends Platform:
@@ -38,6 +41,26 @@ final class BrowserPlatform(canvas: js.Dynamic) extends Platform:
     global.crypto.getRandomValues(buf)
     buf(0).toLong
 
+  // m10: where the best score survives a reload.
+  private val bestKey = "pure-snake-best"
+
+  // Storage can be missing, blocked (privacy settings) or hold anything: all of that reads as 0, and nothing throws.
+  // `window.localStorage` is read inside the `try`, because some browsers throw as soon as it is touched.
+  def loadBest(): Int =
+    try
+      val raw = window.localStorage.getItem(bestKey)
+      if raw == null || js.isUndefined(raw) then 0
+      else
+        // Only what saveBest writes counts: decimal digits, at most Int.MaxValue (so all three tracks read alike).
+        val s = raw.asInstanceOf[String]
+        if s.matches("[0-9]{1,10}") && s.toDouble <= Int.MaxValue then s.toDouble.toInt else 0
+    catch case NonFatal(_) => 0
+
+  // A record that cannot be stored is lost; the game goes on.
+  def saveBest(score: Int): Unit =
+    try window.localStorage.setItem(bestKey, score.toString)
+    catch case NonFatal(_) => () // ignored on purpose
+
   // t is the number of milliseconds since the first animation frame.
   def startClock(onTime: Long => Unit): Unit =
     def frame(start: Option[Double]): js.Function1[Double, Unit] = now =>
@@ -48,3 +71,17 @@ final class BrowserPlatform(canvas: js.Dynamic) extends Platform:
 
   def onKeyDown(cb: String => Unit): Unit = listen("keydown", cb)
   def onKeyUp(cb: String => Unit): Unit = listen("keyup", cb)
+
+  // m13: clicks on the canvas (not the window), converted to canvas pixels. The listener is added only when a runtime
+  // asks for clicks. The page may show the canvas at another size than its width x height (CSS scaling, zoom) and draws
+  // a border around it, so the window coordinates are made relative to the drawing area (bounding rectangle minus the
+  // border, clientLeft/clientTop) and then scaled by the canvas size over its shown size (clientWidth/clientHeight).
+  def onClick(cb: (Int, Int) => Unit): Unit =
+    val handler: js.Function1[js.Dynamic, Unit] = e =>
+      val r = canvas.getBoundingClientRect()
+      def axis(client: String, start: String, border: String, size: String, shown: String): Int =
+        val offset = e.selectDynamic(client).asInstanceOf[Double] - r.selectDynamic(start).asInstanceOf[Double] -
+          canvas.selectDynamic(border).asInstanceOf[Double]
+        math.floor(offset * canvas.selectDynamic(size).asInstanceOf[Double] / canvas.selectDynamic(shown).asInstanceOf[Double]).toInt
+      cb(axis("clientX", "left", "clientLeft", "width", "clientWidth"), axis("clientY", "top", "clientTop", "height", "clientHeight"))
+    canvas.addEventListener("click", handler)