refactor(node): split AggregateCommitteeSignatures into snapshot/prove/apply (#307)

[mananuf]

Summary

Structural split of `AggregateCommitteeSignatures` into snapshot → prove → apply, mirroring ethlambda's `snapshot_aggregation_inputs → aggregate_job → publish` pattern (`ethlambda/crates/blockchain/src/aggregation.rs:120-462`). Pure refactor — no behaviour change. Closes #307.

This PR alone delivers no perf win. Its job is to unlock the prove phase from any `*ConsensusStore` reference, which is the structural prerequisite for Phase D (off-tick async dispatch — separate issue).

What changed

`node/store_aggregate.go`: +113 / -31 LOC.

Two new types + three new helpers replace the monolithic function:

```go
type AggregationSnapshot struct {
headState *types.State
attSigs map[[32]byte]*AttestationDataEntry
newEntries map[[32]byte]*PayloadEntry
knownEntries map[[32]byte]*PayloadEntry
targetStates map[[32]byte]*types.State
}

type AggregationMutations struct {
PayloadEntries []PayloadKV
KeysToDelete []AttestationDeleteKey
}

func snapshotAggregationInputs(s *ConsensusStore) *AggregationSnapshot
func aggregateFromSnapshot(snap *AggregationSnapshot, cache *xmss.PubKeyCache) ([]*SignedAggregatedAttestation, *AggregationMutations)
func applyAggregationMutations(s *ConsensusStore, m *AggregationMutations)
```

`AggregateCommitteeSignatures` becomes the thin wrapper:

```go
func AggregateCommitteeSignatures(s *ConsensusStore) []*types.SignedAggregatedAttestation {
passStart := time.Now()
defer func() { ObserveCommitteeAggregationTime(time.Since(passStart).Seconds()) }()

snap := snapshotAggregationInputs(s)
if snap == nil { return nil }
aggs, mut := aggregateFromSnapshot(snap, s.PubKeyCache)
applyAggregationMutations(s, mut)
return aggs

}
```

`selectChildProofs`' last parameter changes `s *ConsensusStore` → `cache *xmss.PubKeyCache`. That was the only store dependency in its body; threading the cache directly removes the snapshot's only escape hatch into the live store.

Behavior change

None. Same store reads, same FFI calls, same store mutations, in the same order. All four phase-attribution histograms from #305 stay where they were — they wrap the same code spans, just inside the new function boundaries now.

Specifically verified preserved:

• `AttestationSignatures.Snapshot()` is still called once per pass
• `NewPayloads.data` / `KnownPayloads.data` reads happen once per pass
• `GetState(s.Head())` for headState happens once per pass
• `GetState(attData.Target.Root)` happens once per unique target root per pass (with the new `targetStates` cache deduplicating; previously this could be called once per data root even if many shared the same target)

Net effect: very slightly fewer `GetState` calls in the rare case where multiple data roots share a target. Otherwise identical work.

Spec compliance

Zero impact. Structural refactor of gean-side code; no spec-mapped function or container modified. Same store transitions, same broadcast set.

Test plan

• `go build ./...` clean
• `go test -count=1 ./node/...` green
• Post-merge: phase-attribution histograms from perf: instrument interval-2 aggregation path for prep / FFI / post / commit attribution #305 still emit; `prep + ffi + post + commit` still sums to pass-level within ~5%

Lean-review

• `dead-code`: N/A
• `premature-abstraction`: the snapshot/mutations types each have a single use site today, but Phase D consumes them — naming them up front beats a "rewrite the file in Phase D" diff
• `defensive-bloat`: N/A
• `duplicates-existing-util`: N/A
• `comment-bloat`: docstrings on the two new types are 6 and 3 lines; both explain why the type exists (the ethlambda parallel + the async prerequisite), which is non-obvious without context. Earns its keep.
• `over-validated-boundary`: N/A

Stack

Stacks on PR #306 (instrumentation). Base: `perf/instrument-aggregation-phases`. Will be merged with Phases C + D before `perf/instrument-aggregation-phases` itself merges to devnet-4.