perf(graph_builder): release dedup maps after Snapshot (Task A4)

GraphBuilder.Snapshot extracted deduped nodes/edges into sorted slices
but left builder.nodes and builder.edges maps holding references to
the same objects. With the slices and maps coexisting for the rest of
the enrich pipeline (~30 sec wall time on ~/projects/), ~280 MB of
duplicate references stayed live needlessly.

Clear the maps inside Snapshot before returning. Snapshot is now
single-shot — calling it twice on the same builder returns an empty
snapshot (acceptable; the only caller is analyzer.Enrich which calls
once).

Plan: docs/superpowers/plans/2026-05-13-enrich-oom-fix.md Task A4.

Verification:
- New TestSnapshotReleasesDedupMaps asserts both nodes + edges maps
  are nilled after Snapshot returns.
- go test ./... -count=1: 876 pass (no regressions).

Author: aksOps

go/internal/analyzer/graph_builder.go

@@ -85,6 +85,14 @@ type Snapshot struct {
 
 // Snapshot returns the current state as a sorted, dangling-edge-free
 // Snapshot with surfaced dedup/drop counts.
+//
+// After this call returns, the builder's internal dedup maps are cleared
+// (set to nil). This releases ~280 MB of reference pressure at ~/projects/
+// scale where the downstream enrich pipeline holds the returned Snapshot
+// slices for the lifetime of the function — coexisting with the dedup
+// maps was the largest in-memory duplication in the pipeline. Snapshot
+// is therefore single-shot: subsequent calls to Snapshot or Add on the
+// same builder are not supported.
 func (b *GraphBuilder) Snapshot() Snapshot {
 	b.mu.Lock()
 	defer b.mu.Unlock()
@@ -109,11 +117,17 @@ func (b *GraphBuilder) Snapshot() Snapshot {
 	}
 	sort.Slice(edges, func(i, j int) bool { return edges[i].ID < edges[j].ID })
 
-	return Snapshot{
+	snap := Snapshot{
 		Nodes:        nodes,
 		Edges:        edges,
 		DedupedNodes: b.dedupedNodes,
 		DedupedEdges: b.dedupedEdges,
 		DroppedEdges: dropped,
 	}
+	// Release dedup maps so Go GC can collect them while downstream
+	// enrich stages run. The maps held references to every node and
+	// edge already projected into the returned slices.
+	b.nodes = nil
+	b.edges = nil
+	return snap
 }

go/internal/analyzer/graph_builder_test.go

@@ -7,6 +7,21 @@ import (
 	"github.com/randomcodespace/codeiq/go/internal/model"
 )
 
+func TestSnapshotReleasesDedupMaps(t *testing.T) {
+	gb := NewGraphBuilder()
+	gb.Add(&detector.Result{
+		Nodes: []*model.CodeNode{model.NewCodeNode("x", model.NodeClass, "X")},
+		Edges: []*model.CodeEdge{{ID: "e:x:x", SourceID: "x", TargetID: "x", Kind: model.EdgeContains}},
+	})
+	_ = gb.Snapshot()
+	if gb.nodes != nil {
+		t.Errorf("Snapshot must nil GraphBuilder.nodes to allow GC; got len=%d", len(gb.nodes))
+	}
+	if gb.edges != nil {
+		t.Errorf("Snapshot must nil GraphBuilder.edges to allow GC; got len=%d", len(gb.edges))
+	}
+}
+
 func TestGraphBuilderDeduplicatesByID(t *testing.T) {
 	gb := NewGraphBuilder()
 	n1 := model.NewCodeNode("a", model.NodeClass, "A")