feat(kernel): R7b Dart walker — dart module, vendored-grammar-C d4d8f3e + wasm byte-copy vendor, dart default-routed (#1386)

R7b batch 4 #4 — the FINAL R7b language (docs/design/dart-kernel-port-checklist.md
is the authoritative quirk list). The fourth vendored-grammar-C language,
with a twist: production dart resolved its wasm from tree-sitter-wasms,
whose dart dependency is an UNPINNED github:UserNobody14/tree-sitter-dart —
a routine dependency update would have silently changed dart's grammar.
This PR byte-copies the shipping 0.1.13 artifact into src/extraction/wasm/
(VENDORED_WASM_LANGS += dart) and compiles the same-commit (d4d8f3e337d8)
parser.c/scanner.c in the kernel — table identity proven by the
kernel-grammar-parity row. crates.io tree-sitter-dart is the nielsenko
fork (different lineage) — rejected.

The center of gravity is THE SIBLING-BODY DOUBLE-WALK, reproduced
bug-for-bug: dart attaches every function/method body as a NEXT SIBLING of
its signature, and the TS walkers consume each body TWICE — once via
resolveBody (attributed to the function/method) and once via the enclosing
generic walk (attributed to the file/class). Duplicate local-function
nodes with the SAME id under different parents, duplicated
calls/instantiates refs, and file/class-attributed fn-ref twins all emit
in the exact observed interleave (a dedicated fixture pins the
duplicate-id rows; the bloc kind-census spot-check pins the counts).

Also preserved (probe-pinned): the extractBareCall selector matrix (the
first callTypes=[] language — cascades completely invisible, `?.` encodes
like `.`, the `ConfigT.load()` calls+references double emission with no
callee-of-call skip, capitalized-chain `Foo.create().run` re-encode,
const-object callee names); the constructor hooks (unnamed ctor skipped,
named ctors/factories renamed to the CTOR name with the class as
returnType, `@override (T) m()` record-misparse rescued by class-name
validation); operator methods minting `method "<anonymous>"`;
static_final_declaration constants via the visitNode hook while instance
fields mint NOTHING; the prefixed-return-type prefix bug (`other.OtherClass
f()` → returnType `other`); enum `with` mixins silent vs `implements`
working; anonymous extensions named after the ON type; deferred imports
invisible; named-argument callbacks NOT fn-ref-captured (the Flutter
`onPressed:` idiom — future accuracy PR, TS-side first); `async*`/`sync*`
NOT async; value-refs with the LIVE dart sibling-body pull and the
`$X`-vs-`${X}` interpolation asymmetry; dartdoc kept in all three comment
forms with the annotation-broken chain.

Gates: parity sweeps first-run 0-diff on shelf/bloc/flutter — 5,815 clean
files byte-parity, deferrals 10/21/1341 ≈ the survey's 10/21/~1340
(both-arm grammar reality: empty object patterns — the sealed-class
idiom — and unnamed `library;` dominate; --max-deferral 0.3); full-init
dumps byte-identical ×3 (shelf 7,959 / bloc 40,026 / flutter 1,855,319
dump lines); bloc per-kind node census identical across arms (the
double-walk duplicate rows survive the store identically);
kernel-dart-parity suite (7 fixtures + in-memory CRLF variants +
double-walk duplicate-id pin + generated-file skip pin + two defer pins);
full suite 2,688 green ×2 with CODEGRAPH_KERNEL_EXPECT=1.
DEFAULT_ROUTED += dart (20 langs — R7b COMPLETE).

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

codegraph-kernel/grammars/dart/scanner.c

@@ -0,0 +1,130 @@
+#include "tree_sitter/parser.h"
+#include <wctype.h>
+
+enum TokenType {
+  TEMPLATE_CHARS_SINGLE,
+  TEMPLATE_CHARS_DOUBLE,
+  TEMPLATE_CHARS_SINGLE_SINGLE,
+  TEMPLATE_CHARS_DOUBLE_SINGLE,
+  TEMPLATE_CHARS_RAW_SLASH,
+  BLOCK_COMMENT,
+  DOCUMENTATION_BLOCK_COMMENT,
+};
+
+void *tree_sitter_dart_external_scanner_create() { return NULL; }
+void tree_sitter_dart_external_scanner_destroy(void *p) {}
+void tree_sitter_dart_external_scanner_reset(void *p) {}
+unsigned tree_sitter_dart_external_scanner_serialize(void *p, char *buffer) { return 0; }
+void tree_sitter_dart_external_scanner_deserialize(void *p, const char *b, unsigned n) {}
+
+static void advance(TSLexer *lexer) { lexer->advance(lexer, false); }
+static void skip(TSLexer *lexer) { lexer->advance(lexer, true); }
+
+static bool scan_multiline_comments(TSLexer *lexer) {
+
+    bool documentation_comment = false;
+    advance(lexer);
+    if (lexer->lookahead != '*') return false;
+    advance(lexer);
+    if (lexer->lookahead == '*') documentation_comment = true;
+
+    bool after_star = false;
+    unsigned nesting_depth = 1;
+    for (;;) {
+      switch (lexer->lookahead) {
+        case '\0':
+          return false;
+        case '*':
+          advance(lexer);
+          after_star = true;
+          break;
+        case '/':
+          if (after_star) {
+            advance(lexer);
+            after_star = false;
+            nesting_depth--;
+            if (nesting_depth == 0) {
+              if (!documentation_comment) {
+                lexer->result_symbol = BLOCK_COMMENT;
+              } else {
+                lexer->result_symbol = DOCUMENTATION_BLOCK_COMMENT;
+              }
+              return true;
+            }
+          } else {
+            advance(lexer);
+            after_star = false;
+            if (lexer->lookahead == '*') {
+              nesting_depth++;
+              advance(lexer);
+            }
+          }
+          break;
+        default:
+          advance(lexer);
+          after_star = false;
+          break;
+      }
+    }
+  return false;
+}
+
+
+static bool scan_templates(TSLexer *lexer, const bool *valid_symbols) {
+  if(valid_symbols[TEMPLATE_CHARS_DOUBLE]) {
+              lexer->result_symbol = TEMPLATE_CHARS_DOUBLE;
+  } else if (valid_symbols[TEMPLATE_CHARS_SINGLE]) {
+              lexer->result_symbol = TEMPLATE_CHARS_SINGLE;
+  } else if (valid_symbols[TEMPLATE_CHARS_SINGLE_SINGLE]) {
+              lexer->result_symbol = TEMPLATE_CHARS_SINGLE_SINGLE;
+  } else {
+              lexer->result_symbol = TEMPLATE_CHARS_DOUBLE_SINGLE;
+  }
+  for (bool has_content = false;; has_content = true) {
+    lexer->mark_end(lexer);
+    switch (lexer->lookahead) {
+      case '\'':
+      case '"':
+        return has_content;
+      case '\n':
+        if (valid_symbols[TEMPLATE_CHARS_DOUBLE_SINGLE] || valid_symbols[TEMPLATE_CHARS_SINGLE_SINGLE]) return false;
+        advance(lexer);
+        break;
+      case '\0':
+        return false;
+      case '$':
+        return has_content;
+      case '\\':
+        if (valid_symbols[TEMPLATE_CHARS_RAW_SLASH]) {
+            lexer->result_symbol = TEMPLATE_CHARS_RAW_SLASH;
+            advance(lexer);
+        } else {
+            return has_content;
+        }
+        break;
+      default:
+        advance(lexer);
+    }
+  }
+  return true;
+}
+
+
+
+bool tree_sitter_dart_external_scanner_scan(void *payload, TSLexer *lexer,
+                                                  const bool *valid_symbols) {
+  if (
+      valid_symbols[TEMPLATE_CHARS_DOUBLE] ||
+      valid_symbols[TEMPLATE_CHARS_SINGLE] ||
+      valid_symbols[TEMPLATE_CHARS_DOUBLE_SINGLE] ||
+      valid_symbols[TEMPLATE_CHARS_SINGLE_SINGLE]
+  ) {
+    return scan_templates(lexer, valid_symbols);
+  }
+  while (iswspace(lexer->lookahead)) lexer->advance(lexer, true);
+
+  if (lexer->lookahead == '/') {
+    return scan_multiline_comments(lexer);
+  }
+  return false;
+}