Fix non-determinism bug: ensure 100% consistent results across runs

Root cause: as_completed() returned futures in non-deterministic order,
causing files to be processed in varying order across runs. This affected
ModuleContainmentLinker which depends on node insertion order.

Fixes:
- analyzer.py: use indexed result slots to preserve file ordering
  regardless of thread completion order
- builder.py: sort set iteration in TopicLinker for deterministic edges
- store.py: return sorted neighbors instead of non-deterministic set

Verified: terraform-provider-azurerm (42,850 files) now produces
312,232 nodes and 448,540 edges consistently across 3 runs (was
varying by 3-4 nodes previously).

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

Author: aksOps

src/code_intelligence/analyzer.py

@@ -327,25 +327,28 @@ def _report(msg: str) -> None:
                 for f in files_to_analyze
             ]
         else:
-            results = []
             max_workers = min(parallelism, len(files_to_analyze))
+            # Use a list aligned with files_to_analyze to preserve
+            # deterministic ordering regardless of thread completion order.
+            result_slots: list[tuple[DiscoveredFile, DetectorResult] | None] = [None] * len(files_to_analyze)
             with ThreadPoolExecutor(max_workers=max_workers) as executor:
                 futures = {
                     executor.submit(
                         _analyze_file, f, repo_path, self._registry, pm
-                    ): f
-                    for f in files_to_analyze
+                    ): idx
+                    for idx, f in enumerate(files_to_analyze)
                 }
                 for future in as_completed(futures):
+                    idx = futures[future]
                     try:
-                        results.append(future.result())
+                        result_slots[idx] = future.result()
                     except Exception:
-                        src_file = futures[future]
                         logger.warning(
                             "Analysis failed for %s",
-                            src_file.path,
+                            files_to_analyze[idx].path,
                             exc_info=True,
                         )
+            results = [r for r in result_slots if r is not None]
 
         # ----------------------------------------------------------
         # 5. Aggregate results into graph builder

src/code_intelligence/graph/builder.py

@@ -59,8 +59,8 @@ def link(self, store: GraphStore) -> list[GraphEdge]:
                 producers.update(producers_by_topic.get(tid, []))
                 consumers.update(consumers_by_topic.get(tid, []))
 
-            for prod in producers:
-                for cons in consumers:
+            for prod in sorted(producers):
+                for cons in sorted(consumers):
                     if prod != cons:
                         edges.append(
                             GraphEdge(

src/code_intelligence/graph/store.py

@@ -110,7 +110,7 @@ def neighbors(
             for source, _, data in self._g.in_edges(node_id, data=True):
                 if edge_kinds is None or EdgeKind(data.get("kind", "")) in edge_kinds:
                     result.add(source)
-        return list(result)
+        return sorted(result)
 
     def subgraph(self, node_ids: set[str]) -> GraphStore:
         """Create a new GraphStore containing only the specified nodes and edges between them."""