refactor(debugger): exact event→line mapping + tracer-free concept view (#7)

A rigorous QA pass (per-pattern) found the source debugger's heuristic
anchoring mapped events to the wrong line across every pattern, snapped
breakpoints invisibly to unrelated lines, and leaked tracer identifiers
(t *trace.Tracer, t.Pace, a broker t field) into the "concept" view.

Re-architect so the concept and its instrumentation are genuinely separate:

- trace stays the dedicated event library; pacing moves out to a tracer-free
  pace(ctx, d) helper that scales by the speed carried on the context, so
  concept code has no instrumentation.
- Narration hooks are standalone statements sitting directly on the operation
  they describe; registry.go drops the hook lines and the residual tracer
  param/args and maps each event to the exact adjacent statement (above, or
  below for a Block) — an exact, non-heuristic map. Hook-only ifs are dropped
  so no dead {} remains.
- Breakpoints are settable only on real stop lines and fire exactly there —
  no snapping, the dot never moves onto a brace/decl/dead line.
- cmd/genconcepts materializes the pure concept into internal/concepts/<name>/
  (one compilable package per pattern) via `go generate ./...`.
- Fix mismodeling surfaced by QA: buffered blocks only when full, timeout's
  result channel cap, pub-sub broker kind (mutex, not cond), critical-section
  and cancel() now highlight their own line.

Verified across all 27 patterns: 0 tracer leaks, 0 breakpoints on a
brace/blank, 0 events off their stop line. Adds patterns/debug_test.go to
lock the contract.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: burrows99

README.md

@@ -120,14 +120,21 @@ The frontend proxies `/api` and `/healthz` to the backend, so you only open
   step-over*. Stepping advances one **concept line** at a time (several runtime
   events on one line collapse into a single step), so the highlight always
   moves in step with the picture.
-- **Breakpoints** — click the gutter next to any executable statement to set a
-  breakpoint; playback halts when execution reaches it, and **Play** doubles as
-  *continue to next breakpoint*. Only lines that actually run an event are
-  breakpointable — you can never drop a breakpoint on a brace or a dead line.
-- **Clean concept view** — the tracer hooks (`t.Spawn`, `t.Send`, …) are
-  stripped from the displayed source, and every event is mapped, via `go/ast`,
-  onto the real statement it narrates. You read idiomatic Go; you debug idiomatic
-  Go.
+- **Breakpoints** — click the gutter next to any line that actually runs a step
+  (a send, a receive, a spawn, a lock, the critical section, a `cancel()`…) to
+  set a breakpoint; playback halts **exactly** on that line, and **Play** doubles
+  as *continue to next breakpoint*. The dot never moves and never lands on a
+  brace, a declaration, or a dead line — the breakpoint stops precisely where it
+  sits.
+- **Clean concept view** — the tracer hooks (`t.Spawn`, `t.Send`, …) live on
+  their own lines and are stripped from the displayed source, along with the
+  `t *trace.Tracer` parameter and the pacing calls, so what you read is **pure,
+  idiomatic Go** — no instrumentation leaks in. Every event is mapped onto the
+  exact statement it narrates (the hook sits directly on that statement), so
+  highlight and breakpoints are precise, not heuristic. The same pure source is
+  also materialized into [`backend/internal/concepts/`](backend/internal/concepts)
+  — one compilable package per pattern — so you can read (and `go build`) the
+  concept on its own.
 
 Each pattern also ships **How it works** and **Interview notes** tabs.
 
@@ -151,8 +158,11 @@ Each pattern also ships **How it works** and **Interview notes** tabs.
 ```
 backend/
   cmd/server/main.go            entrypoint (graceful shutdown via signal.NotifyContext)
-  internal/trace/trace.go       the instrumentation layer (Tracer, Event, source-line capture)
-  internal/patterns/*.go        one file per demo (+ registry.go: catalog, go/ast source mapping)
+  cmd/genconcepts/main.go       generates internal/concepts/ from the instrumented demos
+  internal/trace/trace.go       the dedicated event library (Tracer, Event, source-line capture)
+  internal/patterns/*.go        one file per demo (+ registry.go: catalog + go/ast strip/map)
+  internal/patterns/helpers.go  pace(): the pure, speed-scaled sleep (no tracer)
+  internal/concepts/<name>/     generated pure-Go concept, one compilable package per pattern
   internal/server/server.go     catalog + SSE routes
 frontend/
   src/App.tsx                   layout, run orchestration, the debugger play-head
@@ -163,13 +173,19 @@ frontend/
 docker-compose.yml              backend + frontend, one command
 ```
 
-- **`trace`** — a `Tracer` that pattern code calls to narrate itself (`Spawn`,
-  `Send`, `Recv`, `Block`, `Lock`, `Cancel`, …). Each call becomes a JSON
-  `Event` stamped with the source line it came from. `Pace()` inserts the real,
-  cancellable sleeps that make a run watchable. Safe for concurrent use.
+- **`trace`** — the dedicated event library. A `Tracer` that pattern code calls
+  to narrate itself (`Spawn`, `Send`, `Recv`, `Block`, `Lock`, `Cancel`, …); each
+  call becomes a JSON `Event` stamped with the source line it came from. Safe for
+  concurrent use. Pacing is deliberately *not* here — the watchable, cancellable
+  delay is `patterns.pace(ctx, d)`, a tracer-free helper that scales by the run
+  speed carried on the context — so the concept code stays instrumentation-free.
 - **`patterns`** — each demo registers itself and exposes `Run(ctx, *Tracer)`.
-  The source is `//go:embed`-ed; at catalog time `go/ast` strips the trace hooks
-  and builds the event → concept-line map that powers the debugger.
+  Narration hooks are written as their own statements sitting directly on the
+  concept operation they describe. The source is `//go:embed`-ed; at catalog time
+  `registry.go` drops the hook lines and the residual tracer parameter and maps
+  each event to the exact adjacent statement — an exact, non-heuristic map. The
+  same strip feeds `cmd/genconcepts`, which writes the pure concept out to
+  `internal/concepts/` (`go generate ./...`).
 - **`server`** — `GET /api/patterns` returns the catalog;
   `GET /api/stream?pattern=…&speed=…` runs one pattern and streams its events as
   SSE. The run is bound to the request context, so aborting the fetch (the