feat(analyzer/linker): defensive sort at the linker boundary

Plan Phase 1.4 — even if a future Linker change accidentally re-introduces
map-iteration order drift, the boundary call site sorts the result before
appending into the working node/edge slices. Result.Sorted() helper added
to linker.go; enrich.go applies it after every Link() call.

Test: TestLinkerDeterminism_ShuffledInput shuffles the same input set
with two different seeds and asserts the sorted output is byte-identical.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: aksOps

go/internal/analyzer/enrich.go

@@ -70,12 +70,14 @@ func Enrich(root string, c *cache.Cache, opts EnrichOptions) (EnrichSummary, err
 	edges := snap.Edges
 
 	// 1. Linkers — order matches Analyzer.java.
+	// Plan §1.4 — Sorted() at the boundary makes the output independent of
+	// any linker's internal iteration order.
 	for _, l := range []linker.Linker{
 		linker.NewTopicLinker(),
 		linker.NewEntityLinker(),
 		linker.NewModuleContainmentLinker(),
 	} {
-		r := l.Link(nodes, edges)
+		r := l.Link(nodes, edges).Sorted()
 		nodes = append(nodes, r.Nodes...)
 		edges = append(edges, r.Edges...)
 	}

go/internal/analyzer/linker/determinism_test.go

@@ -0,0 +1,75 @@
+package linker
+
+import (
+	"math/rand"
+	"reflect"
+	"testing"
+
+	"github.com/randomcodespace/codeiq/go/internal/model"
+)
+
+// TestLinkerDeterminism_ShuffledInput — Plan §1.6.
+// Same set of nodes/edges in two different orders must produce identical
+// sorted output through Sorted().
+func TestLinkerDeterminism_ShuffledInput(t *testing.T) {
+	build := func(seed int64) Result {
+		nodes := []*model.CodeNode{
+			model.NewCodeNode("c", model.NodeClass, "c"),
+			model.NewCodeNode("a", model.NodeClass, "a"),
+			model.NewCodeNode("b", model.NodeClass, "b"),
+		}
+		edges := []*model.CodeEdge{
+			model.NewCodeEdge("e3", model.EdgeCalls, "c", "a"),
+			model.NewCodeEdge("e1", model.EdgeCalls, "a", "b"),
+			model.NewCodeEdge("e2", model.EdgeCalls, "b", "c"),
+		}
+		r := rand.New(rand.NewSource(seed))
+		r.Shuffle(len(nodes), func(i, j int) { nodes[i], nodes[j] = nodes[j], nodes[i] })
+		r.Shuffle(len(edges), func(i, j int) { edges[i], edges[j] = edges[j], edges[i] })
+		return Result{Nodes: nodes, Edges: edges}.Sorted()
+	}
+
+	r1 := build(1)
+	r2 := build(2)
+	if !sameNodeIDs(r1.Nodes, r2.Nodes) {
+		t.Errorf("node order non-deterministic: %v vs %v", nodeIDs(r1.Nodes), nodeIDs(r2.Nodes))
+	}
+	if !sameEdgeIDs(r1.Edges, r2.Edges) {
+		t.Errorf("edge order non-deterministic")
+	}
+	if !reflect.DeepEqual(nodeIDs(r1.Nodes), []string{"a", "b", "c"}) {
+		t.Errorf("sort order wrong: %v", nodeIDs(r1.Nodes))
+	}
+}
+
+func nodeIDs(ns []*model.CodeNode) []string {
+	out := make([]string, len(ns))
+	for i, n := range ns {
+		out[i] = n.ID
+	}
+	return out
+}
+
+func sameNodeIDs(a, b []*model.CodeNode) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i].ID != b[i].ID {
+			return false
+		}
+	}
+	return true
+}
+
+func sameEdgeIDs(a, b []*model.CodeEdge) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i].ID != b[i].ID {
+			return false
+		}
+	}
+	return true
+}

go/internal/analyzer/linker/linker.go

@@ -6,14 +6,28 @@
 // Mirrors src/main/java/io/github/randomcodespace/iq/analyzer/linker/.
 package linker
 
-import "github.com/randomcodespace/codeiq/go/internal/model"
+import (
+	"sort"
+
+	"github.com/randomcodespace/codeiq/go/internal/model"
+)
 
 // Result is the bag of new nodes + edges a linker contributes.
 type Result struct {
 	Nodes []*model.CodeNode
 	Edges []*model.CodeEdge
 }
 
+// Sorted returns r with Nodes and Edges sorted by ID. Plan §1.4 — a
+// defensive wrapper applied at the linker boundary so a future linker
+// change can't re-introduce drift even if its internal map-iteration
+// order shifts.
+func (r Result) Sorted() Result {
+	sort.SliceStable(r.Nodes, func(i, j int) bool { return r.Nodes[i].ID < r.Nodes[j].ID })
+	sort.SliceStable(r.Edges, func(i, j int) bool { return r.Edges[i].ID < r.Edges[j].ID })
+	return r
+}
+
 // Linker mirrors the Java Linker interface. Implementations MUST be
 // deterministic — same input slices in must produce identical output every
 // time (sort any map iteration before emitting).