fix(analysis): revert _clone_collector to copy.deepcopy (#293)

[allmonday]

Resolves #293.

Summary

bfba588 (2026-06-09) replaced copy.deepcopy with a hand-written _clone_collector that bypassed __init__ via cls.__new__(cls) and copied only alias/flat/val. This was a perf optimization, but it silently broke every collector shape beyond the default list-based Collector:

• Direct ICollector implementations lost any attribute set in __init__ (e.g. key_fn) → AttributeError on first add().
• Collector subclasses with extra __init__ config (e.g. n, window_size) lost it.
• Collectors whose val is a dict/set/custom aggregator had their val hard-coded back to [] by the framework.

This PR reverts to copy.deepcopy. Transparent to users — any collector implementation works without modification.

Change

+ import copy
  ...
  def _clone_collector(collector):
-     cls = collector.__class__
-     new = cls.__new__(cls)
-     new.alias = collector.alias
-     if hasattr(collector, 'flat'):
-         new.flat = collector.flat
-     new.val = []
-     return new
+     return copy.deepcopy(collector)

Perf

Concern: how much does this give back from bfba588?

Micro-benchmark (Collector('alias') proto, 100k iterations):

	per call	ratio
copy.deepcopy	2.89 us	22x slower
hand-written _clone_collector	0.13 us	baseline

The 22x ratio is real but the absolute cost is tiny — typical Collector proto has 3 simple attributes (alias: str, flat: bool, val: list).

End-to-end benchmarks (pytest benchmarks/):

15 scenarios ran on both versions. Differences were within ±10% and bidirectional — pure noise (each benchmark's own StdDev is 30-100% of mean). No measurable regression. bfba588's advertised 10-14% gains came from the other optimizations in that commit (object.__setattr__, isinstance fast path, metadata caching), not from the collector clone change.

Realistic scale (worst-case estimate):

Clone count per resolve	Added overhead
10	0.03 ms
200	0.55 ms
1 000	2.75 ms
10 000	27.5 ms

For context: a single SQL query is 1–10 ms. Collectors live in post_* methods, which are typically IO-bound (DataLoader batches) — the deepcopy overhead is invisible.

Test plan

• tests/resolver/test_collector_subclass.py (added in prior commit on this branch) — 5 scenarios. Pre-fix: 1/5 pass. Post-fix: 5/5 pass.
  • MapCollector (implements ICollector, dict val, key_fn config)
  • Sibling branch isolation (two Post nodes under one Root)
  • Sequential resolve() on same Resolver
  • TopNCollector (Collector subclass with n config)
  • SimpleSubCollector (backward-compat baseline — must not regress)
• Full suite: 786 passed, 1 skipped.
• ruff check clean.

🤖 Generated with Claude Code