feat(pipeline): route to the lightest correct methodology; move execution loops onto the Workflow substrate

The selector forced every task through the heaviest methodology's
critical path: a behaviour-preserving, type-enumerable change paid the
same specify -> planner -> implement front-half as a novel feature,
because it was neither new behaviour (tdd) nor an observed bug (debug)
and so fell to specify by elimination. Two coupled defects — a selector
with no verification axis, and an all-or-nothing executor — kept the
existing lighter path unreachable and uneconomical. This fixes both.

Part A — verification-keyed selector (boss/SKILL.md):
- Replace the three-way "design line" with an ordered cascade that adds
  a verification/enumeration axis ahead of the settled-vs-fork question.
  Each lighter arm carries a positive trigger matched by signature, not
  reached by elimination.
- New `compiler-driven` arm: a type/signature edit at a definition site
  that propagates mechanically. Observe-then-bounce — make the edit,
  build, run the suite; clean build AND suite green unchanged commits;
  a hole bounces up (specify for a design choice, tdd for discovered
  test-specifiable new behaviour); a regression bounces to debug.
- The observed-bug RED-first gate is first in the cascade, so a
  mechanical-looking fix cannot bypass it.
- The straddle rule ("add an enum variant") is codified as a rule:
  mechanical/forwarding -> compiler-driven; encodes new behaviour ->
  tdd/spec; doubt routes up.
- The executor is the elevated inline carve-out plus a shipped workflow,
  not a heavy new skill ("the largest concrete win is small").

Part B — Workflow substrate (implement/workflows/):
- implement-loop.js: the per-task loop as a deterministic script. Each
  phase (implementer -> spec-compliance -> quality, + tester for E2E) is
  a separate top-level agent() call, so a single phase is independently
  invokable and inter-phase aggregation/re-loop is code. Retires the
  implement-orchestrator agent's inline-role-switch workaround (the four
  phase agents survive as the agent-types the script dispatches).
- compiler-driven-edit.js: the observe-then-bounce loop.
- install.sh / uninstall.sh symlink shipped workflows into
  ~/.claude/workflows/.
- specify and brainstorm stay prose + interactive (human-intent oracle);
  only the autonomous/mechanical loops moved. try-and-error is deferred.

Docs (pipeline taxonomy, design, agent-template, migration, README) and
all selector<->executor cross-references updated; the arm and its
executor are co-located so a future re-route through the full loop is a
visible regression.

Verified by an adversarial multi-agent pass: PASS on all six acceptance
criteria; two coherence concerns fixed. The shipped scripts are
syntax-validated but exercised only in a downstream target project (the
skills repo is not itself a pipeline target).

closes #7

implement/agents/implementer.md

@@ -12,11 +12,11 @@ You are the **implementer** for this project. You are
 dispatched by the `implement` skill per task, with a fresh
 context every time.
 
-(In current Claude Code, this agent is consulted as a
-*phase reference* by `implement-orchestrator` Phase 2.1 —
-the orchestrator-agent adopts your mindset for the inline
-implementer phase. It is not separately dispatched as a
-nested subagent.)
+(You are dispatched as the **implementer phase** of the
+`implement-loop` workflow (`../workflows/implement-loop.js`) —
+one `agent()` call per task, fresh context each time. The
+workflow re-dispatches you with the reviewer's findings as a
+repair brief when a check phase comes back non-compliant.)
 
 ## What this role is for
 
@@ -167,10 +167,10 @@ substitute.
    production code and start over. (TDD is letter-and-
    spirit.)
 9. Report. Your changes stay in the working tree as
-   unstaged edits. You do NOT commit. The orchestrator-
-   agent's spec-compliance and quality phases read your
-   work via `git diff HEAD`; the outer orchestrator commits
-   at the end of the iter.
+   unstaged edits. You do NOT commit. The workflow's
+   spec-compliance and quality phases — separate `agent()`
+   calls — read your work via `git diff HEAD`; the
+   orchestrator commits at the end of the iter.
 
 ## Status protocol