fix(han-planning): pin shared contracts before implementation

[mxriverlynn]

Summary

• Adds a contract-pinning checkpoint to the planning chain so a shared interface or data contract reaches concrete, buildable form before implementation instead of being invented mid-build. Closes Planning chain lets shared interface/data contracts reach implementation un-pinned (invented mid-build) #107.
• One new owned rule (han-planning/references/contract-pinning-rule.md) consumed by four skills, plus one executable check with 15 Bats tests.
• Second commit is guidance conformance and is reviewable on its own: script invocations converted from fenced blocks to prose across five skills, and plan-a-feature/SKILL.md brought under the 500-line ceiling.

Why

The chain (plan-a-feature → plan-implementation → plan-work-items, with iterative-plan-review as backstop) had no checkpoint forcing a contract into concrete form, so a "trusted" implementation plan could ship one as a to-be-authored deliverable. In the grounding incident the ledger's entry types were named but its line grammar never was: the schema doc shipped without it, a scanner invented a parsing regex against the undefined format, and the real grammar was retrofitted a day later. Zero of 17 review findings raised the gap.

Two additive gaps caused it. plan-implementation never required a contract in concrete form, and plan-work-items split one contract across items with no rule against it. Fixing either alone leaves the other live.

What reviewers should look at closely

The rule is binary, with no deferred-with-reason state. That was deliberate: an author who has an escape hatch writes "the grammar depends on the serialization library, TBD at build" and passes while leaving the same hole.

The new aggregation check stays out of the spec-maturity gate. That gate counts findings from distinct specialists, and a binary condition bolted onto counted logic breaks it. An unpinned contract raises an OQ-N instead, which the Step 6 loop already knows how to settle.

plan-work-items now reads the plan's Open Items. It previously never looked at that section at all, so a non-blocking open item vanished at the last stage that could see it. This came from a comment on the issue and generalizes past contracts.

The script is the only non-prose enforcement. Nine of ten changes are instructions followed by the same class of agent that missed the gap. check-contract-pinning.sh reports four failure classes separately and skips fenced blocks so a worked example never reads as a deferral. Two tests guard it beyond behavior: the per-skill copies stay byte-identical, and every phrase the script owns appears in the canonical rule.

How to verify

• npm run lint
• npm test (95 tests, 15 of them new)
• bash han-planning/skills/plan-implementation/scripts/check-contract-pinning.sh <a plan file> <its folder> against a real plan folder
• Read han-planning/references/contract-pinning-rule.md first; every other change cites it

Risk / rollback

Low. Nothing here changes an existing check's pass condition, and the one new executable check is additive. The largest behavioral change is that plan-implementation now treats an unpinned contract as reason to keep iterating rather than to ship, which can add a round on a plan that introduces a format. Revert with git revert.

Not in this PR

• No version bump and no CHANGELOG entry; both belong to /han-release.
• feature-implementation-plan-template.md is 163 lines with no Contents list. It is a document skeleton, so a Contents list would be copied into every plan it generates. Left as-is deliberately.