Reduce template compilation overhead

[joelhawksley]

Summary

A set of allocation- and CPU-focused optimizations for the parse + compile
path, found by profiling Herb::Engine compilation of a large real-world
template corpus (~700 .html.erb files). Each optimization is in its own commit.

Measured on that corpus (Ruby 3.4.9 +PRISM, compiling with validation
disabled), versus v0.10.2:

• Compile time: −36% (≈281 µs → ≈181 µs per template)
• Parse allocations: −72%; compile-path allocations −67%
• Compiled output is byte-identical across the whole corpus and a set of
  adversarial whitespace/trim cases
• Hot-path (post-compile) rendering behavior is unchanged

Optimizations (one per commit)

1. track_locations parse option — Herb.parse builds a Location (two
   Positions) for every node and token. Callers that never read source
   locations (e.g. rendering with validation off) can pass
   track_locations: false to leave them nil, skipping roughly half of the
   parse's Ruby allocations. Defaults to true, so existing behavior is
   unchanged.

2. Intern node/token type strings and short token values — type strings and
   short token values are drawn from tiny fixed vocabularies (~96% of token
   values are duplicates like "\n", "%>", ">", tag names). Interning
   shares one frozen String per distinct value instead of allocating a fresh
   copy each time. Longer token values (arbitrary text) are left as-is.

3. Skip the recursive error walk for cleanly-parsed templates —
   ParseResult#errors walked the entire AST (value.recursive_errors) on
   every call. Count errors as they are materialized and record the total on the
   result; when it is zero (the common case), return the top-level errors and
   skip the walk entirely.

4. Accumulator-based Node#recursive_errors — replace
   errors + compact_child_nodes.flat_map(&:recursive_errors) (which allocates
   an intermediate array at every node) with a single shared accumulator walked
   iteratively.

5. Lazy Engine#relative_file_path — was computed eagerly with
   Pathname#relative_path_from + #to_s on every compile, but is only used
   when emitting errors, overlays, or debug output. Derive it on demand instead.

6. Fuse whitespace compaction into optimize_tokens; use String#match? —
   fold the separate compact_whitespace_tokens pass (which built an
   intermediate array via map.with_index + compact) into optimize_tokens'
   single pass, and switch the boolean-context regexp guards in the whitespace
   helpers from =~ to String#match? (no MatchData allocation, no $~).

Notes

• The only public API change is the additive track_locations: option on
  Herb.parse.
• Generated files (ext/herb/nodes.c, ext/herb/error_helpers.c) are not
  committed; the changes live in their .erb templates.
• Verification: compiled Herb::Engine#src output is byte-for-byte identical to
  v0.10.2 across all ~700 corpus templates and a set of hand-crafted
  whitespace/trim edge cases; the downstream ReActionView test suite passes
  against this build.

---

This PR was written with Claude Opus 4.8.

[joelhawksley]

@marcoroth I just took a first pass at trying to improve compilation performance with a lot of help from Claude. What do you think of these changes? I'm also happy to pursue any other approaches you have in mind.