fix(intelligence): GoLanguageExtractor duplicate IMPORTS edges (RAN-170)

collectImportPaths() used an ArrayList allowing duplicate paths when a file
has both a block import and a single-line import for the same package path.
Switch to LinkedHashSet for deduplication (insertion order preserved), then
return a new ArrayList to maintain the List<String> contract.

Added test: extract_duplicateImportBothStyles_noDuplicateEdges verifies that
a file with both import styles for the same package produces exactly one
IMPORTS edge.

Co-Authored-By: Paperclip <noreply@paperclip.ing>

Author: aksOps

src/main/java/io/github/randomcodespace/iq/intelligence/extractor/go/GoLanguageExtractor.java

@@ -12,8 +12,10 @@
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -104,7 +106,7 @@ private List<CodeEdge> extractImportEdges(DetectorContext ctx, CodeNode node,
     }
 
     private List<String> collectImportPaths(String content) {
-        List<String> paths = new ArrayList<>();
+        Set<String> paths = new LinkedHashSet<>();
 
         Matcher block = IMPORT_BLOCK.matcher(content);
         if (block.find()) {
@@ -119,7 +121,7 @@ private List<String> collectImportPaths(String content) {
             paths.add(single.group(1));
         }
 
-        return paths;
+        return new ArrayList<>(paths);
     }
 
     /**

src/test/java/io/github/randomcodespace/iq/intelligence/extractor/go/GoLanguageExtractorTest.java

@@ -97,6 +97,36 @@ void extract_confidence_isPartial() {
         assertThat(result.confidence()).isEqualTo(CapabilityLevel.PARTIAL);
     }
 
+    @Test
+    void extract_duplicateImportBothStyles_noDuplicateEdges() {
+        CodeNode source = node("go:main.go:fn:main", NodeKind.METHOD, "main");
+        CodeNode target = node("go:handler.go:module:handler", NodeKind.MODULE, "handler");
+
+        Map<String, CodeNode> registry = Map.of(target.getLabel(), target);
+
+        // File has both a block import and a single-line import for the same package.
+        // collectImportPaths() must deduplicate so only one IMPORTS edge is produced.
+        String content = """
+                package main
+
+                import (
+                    "myapp/handler"
+                )
+                import "myapp/handler"
+
+                func main() {
+                    handler.Handle()
+                }
+                """;
+
+        DetectorContext ctx = new DetectorContext("main.go", "go", content, registry, null);
+        LanguageExtractionResult result = extractor.extract(ctx, source);
+
+        assertThat(result.symbolReferences()).hasSize(1);
+        assertThat(result.symbolReferences().get(0).getKind()).isEqualTo(EdgeKind.IMPORTS);
+        assertThat(result.symbolReferences().get(0).getTarget().getId()).isEqualTo(target.getId());
+    }
+
     @Test
     void extract_determinism_sameTwice() {
         CodeNode source = node("go:a.go:fn:run", NodeKind.METHOD, "run");