perf: audit against high-performance-go.md, fix 5 confirmed hot paths

[jeduden]

Summary

Scheduled performance audit of the codebase against
docs/development/high-performance-go.md, following that doc's
"apply best-practice patterns first, then measure" playbook. Five
parallel agents scanned the core lint pipeline, all internal/rules/*
packages (split alphabetically), and the supporting/infra packages for
violations of the documented patterns. Findings were ranked by how hot
the call site is and how confidently the fix preserves existing
behavior; the top 5 were fixed, each with a red/green test.

Three rounds of xhigh-severity adversarial review ran against this
PR, each fixing what the previous round found, including two cases
where a "fix" was itself measurably wrong — exactly the failure mode
this kind of PR is most at risk of. The corrections are their own
commits so the history shows what was found and how it was fixed,
rather than being squashed away.

Two other candidate findings from the initial scan were investigated
and deliberately not applied:

• Adding a raw-byte pre-check before mdtext.ExtractPlainText in
  forbiddentext/forbiddenparagraphstarts (MDS055/MDS056) looked
  promising but is unsafe: markdown markup stripped during plain-text
  extraction (e.g. wor**d** → word) can join a configured
  substring that never appears contiguously in the raw source, so a
  raw-source pre-check would introduce false negatives.
• A duplicate of the same O(H×P) rescan pattern also exists in
  occurrence (MDS060) and maxsectionlength (MDS036), using
  different aggregation logic than astutil.SectionBody. Left for a
  follow-up rather than risking a rushed fix across three different
  per-range aggregation loops.

Final fixes (5)

1. internal/config: skip a discarded provenance-selector
   allocation in kind resolution. resolveEffectiveKinds runs on
   every workspace file (it feeds EffectiveSignature, the config
   cache key) and, for every matching kind-assignment entry, called
   matchKindAssignmentEntry, which unconditionally built
   formatSelector's provenance string and threw it away. Split out
   a bool-only kindAssignmentEntryMatches for the hot path.
2. internal/rules/astutil: turn SectionBody's O(H×P) per-heading
   rescan into O(H+P). MDS057/MDS058 call SectionBody once per
   heading, each call rescanning the entire paragraphs slice from
   index 0. Heading start lines are non-decreasing in document order,
   so a single forward-only cursor can skip past already-passed
   paragraphs. Added SectionBodies, computing every heading's body
   in one sweep, with its per-heading text buffer hoisted and reused
   (parts[:0]) rather than re-declared each iteration — the first
   version of this fix actually allocated more than the code it
   replaced (10 allocs vs. 6 on a nested-heading fixture); review
   round 3 caught it.
3. internal/build: resolve build-target inputs/outputs once per
   staleness check. CheckStaleness resolved a target's inputs and
   outputs, then called ComputeActionID, which re-ran the same
   resolveInputs/resolveOutputs from scratch. Reuses the
   already-resolved slices via computeActionIDFromResolved, matching
   what RecordBuild already did.
4. internal/config: skip cloning the discarded side of a
   list-setting merge. mergeAny deep-cloned the earlier side of
   a list-typed settings leaf before checking whether the merge mode
   was Append or the default Replace, discarding the clone on the
   common Replace path, then made a second redundant copy of the
   already-cloned later side. Check the mode first; only clone
   earlier when Append needs it; return later's clone directly
   on Replace — with an explicit fold back to nil for an empty
   later list, since review round 1 caught that the direct-return
   version silently turned a merged nil into a non-nil []any{}
   (observable in mdsmith kinds resolve --json).
5. internal/rules/codeblockstyle: pre-size collectBlocksL0's
   block slice to the actual code-block count, not
   len(BlockSpans) (which counts every block kind — headings,
   paragraphs, lists, quotes — so presizing to it over-allocates on
   the common case of a mostly-prose file). Counts the real code-block
   spans in a first cheap pass, indexing rather than range-copying the
   32-byte BlockSpan struct (review round 3 caught that range-by-value
   made the common case measurably slower than doing nothing).

Reverted from the original top 5

internal/discovery/internal/globpath: caching pattern validation
for the files: glob walk. Review round 1 benchmarked it on the
real walk shape and found no significant change (benchstat p=0.912,
above the project's own p<0.05 bar), while the new MatchRaw helper
was not actually equivalent to doublestar.Match on patterns that
fail ValidatePattern but that Match still accepts. No live bug at
the one call site, but not worth carrying a correctness trap for a
change with no measured benefit — reverted outright and replaced by
fix 5 above.

What each review round found and fixed

• Round 1: nil-vs-[] correctness regression in fix 4's replace
  path (fixed); no measured benefit + a semantic gap in the
  discovery/globpath change (reverted); missing precondition docs on
  SectionBodies (added).
• Round 2: fix 5's first draft (presize to len(BlockSpans)) was
  a measured regression on the common case — ~20x over-allocation,
  ~14x slower on a prose-only fixture (fixed with a count-first pass);
  the SectionBodies precondition doc named only paragraph ordering,
  missed that headings must also be sorted (added); an undocumented
  peak-live-memory trade-off in the batch API (documented).
• Round 3: fix 5's count-first pass itself range-copied the
  32-byte BlockSpan struct, making the fix for the regression
  ~1.85x slower than doing nothing on the common case (fixed by
  indexing instead); fix 2's hoisted parts buffer wasn't actually
  hoisted, so it allocated more than the O(H×P) code it replaced
  (fixed); a doc comment claiming unchanged allocation volume was
  measurably false (corrected); added a consistency test between two
  hand-maintained type switches (isAnySliceType/toAnySlice) that
  had nothing enforcing they stay in sync.

Every fix above and every correction was independently verified with
its own differential/fuzz test, allocation-budget test, or benchmark —
not just asserted. Full details are in the individual commit messages.

Test plan

• Each fix has a dedicated red→green test (testing.AllocsPerRun
  budget test, or an equivalence/call-count test where allocation
  counting doesn't capture the win) written before the fix, shown
  failing, then passing after.
• go build ./...
• go test ./... (all 161 packages pass)
• go vet ./...
• go tool -modfile=tools/go.mod golangci-lint run ./... (0 issues,
  full repo)
• go run ./cmd/mdsmith check . (567 files checked, 0 failures)
• internal/integration corpus/allocation-budget suites pass
  unchanged
• Three xhigh-severity adversarial review rounds, each addressing
  every confirmed finding from the previous round

Ref: docs/development/high-performance-go.md

🤖 Generated with Claude Code

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 98.71%. Comparing base (2ab4b29) to head (7e54245).

Additional details and impacted files

Components	Coverage Δ
Go	98.70% <100.00%> (+<0.01%)	⬆️
TypeScript	99.54% <ø> (ø)

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.