refactor: Extract per-language configs and standalone extractors from tree-sitter.ts

Splits the monolithic tree-sitter.ts (3,358 lines) into modular files:
- 14 language config files under src/extraction/languages/
- 3 standalone extractors (Liquid, Svelte, DFM)
- Shared helpers and types modules to avoid circular imports

Also fixes a bug where Java's extractImport hook incorrectly set
handledRefs: true, preventing unresolved reference creation and
degrading codegraph_explore results for Java codebases.

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

src/extraction/languages/pascal.ts

@@ -0,0 +1,62 @@
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+import { getNodeText, getChildByField } from '../tree-sitter-helpers';
+import type { LanguageExtractor } from '../tree-sitter-types';
+
+export const pascalExtractor: LanguageExtractor = {
+  functionTypes: ['declProc'],
+  classTypes: ['declClass'],
+  methodTypes: ['declProc'],
+  interfaceTypes: ['declIntf'],
+  structTypes: [],
+  enumTypes: ['declEnum'],
+  typeAliasTypes: ['declType'],
+  importTypes: ['declUses'],
+  callTypes: ['exprCall'],
+  variableTypes: ['declField', 'declConst'],
+  nameField: 'name',
+  bodyField: 'body',
+  paramsField: 'args',
+  returnField: 'type',
+  getSignature: (node, source) => {
+    const args = getChildByField(node, 'args');
+    const returnType = node.namedChildren.find(
+      (c: SyntaxNode) => c.type === 'typeref'
+    );
+    if (!args && !returnType) return undefined;
+    let sig = '';
+    if (args) sig = getNodeText(args, source);
+    if (returnType) {
+      sig += ': ' + getNodeText(returnType, source);
+    }
+    return sig || undefined;
+  },
+  getVisibility: (node) => {
+    let current = node.parent;
+    while (current) {
+      if (current.type === 'declSection') {
+        for (let i = 0; i < current.childCount; i++) {
+          const child = current.child(i);
+          if (child?.type === 'kPublic' || child?.type === 'kPublished')
+            return 'public';
+          if (child?.type === 'kPrivate') return 'private';
+          if (child?.type === 'kProtected') return 'protected';
+        }
+      }
+      current = current.parent;
+    }
+    return undefined;
+  },
+  isExported: (_node, _source) => {
+    // In Pascal, symbols declared in the interface section are exported
+    return false;
+  },
+  isStatic: (node) => {
+    for (let i = 0; i < node.childCount; i++) {
+      if (node.child(i)?.type === 'kClass') return true;
+    }
+    return false;
+  },
+  isConst: (node) => {
+    return node.type === 'declConst';
+  },
+};