AST-based route registration + remove prescan infrastructure

Route registration detection during AST extraction: callee QN matched
against router frameworks (gin, chi, Express, Laravel, Ktor, etc.),
handler reference captured as second_arg_name, Route + HANDLES edges
created during resolution. Replaces disk-reading route discovery for
non-decorator frameworks.

Remove prescan infrastructure entirely (-350 net lines):
- cbm_prescan_t, cbm_prescan_http_site_t, cbm_prescan_route_t,
  cbm_prescan_config_ref_t structs removed from pipeline_internal.h
- prescan_http_sites, prescan_routes, prescan_config_refs,
  prescan_add_route removed from pass_parallel.c
- prescan fast-paths removed from pass_httplinks.c and pass_configlink.c
- prescan allocation/cleanup removed from pipeline.c

All post-passes now work without prescan:
- HTTP/async edges: service_patterns during resolution
- Route registration: CBM_SVC_ROUTE_REG during resolution
- Decorator routes: gbuf properties (no disk reads)
- Config file refs: disk fallback (few files)

Author: DeusData

internal/cbm/cbm.h

@@ -111,6 +111,7 @@ typedef struct {
     const char *callee_name;       // raw callee text ("pkg.Func", "foo")
     const char *enclosing_func_qn; // QN of enclosing function (or module QN)
     const char *first_string_arg;  // first string literal argument (URL, topic, key) or NULL
+    const char *second_arg_name;   // second argument identifier (handler ref) or NULL
 } CBMCall;
 
 typedef struct {

internal/cbm/extract_calls.c

@@ -267,7 +267,7 @@ static void walk_calls(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *spec)
         if (callee && callee[0]) {
             // Skip keywords
             if (!cbm_is_keyword(callee, ctx->language)) {
-                CBMCall call;
+                CBMCall call = {0};
                 call.callee_name = callee;
                 call.enclosing_func_qn = cbm_enclosing_func_qn_cached(ctx, node);
                 call.first_string_arg = NULL;
@@ -504,6 +504,26 @@ void handle_calls(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *spec, Walk
                 }
             }
 
+            /* Extract second argument name (handler ref for route registrations).
+             * Pattern: router.GET("/path", handlerFunc) → second_arg_name = "handlerFunc"
+             * Only extracted when first_string_arg looks like a path. */
+            if (call.first_string_arg != NULL && call.first_string_arg[0] == '/' &&
+                !ts_node_is_null(args)) {
+                uint32_t nc2 = ts_node_named_child_count(args);
+                for (uint32_t ai = 1; ai < nc2 && ai < 4 && !call.second_arg_name; ai++) {
+                    TSNode arg2 = ts_node_named_child(args, ai);
+                    const char *ak2 = ts_node_type(arg2);
+                    if (strcmp(ak2, "identifier") == 0) {
+                        call.second_arg_name = cbm_node_text(ctx->arena, arg2, ctx->source);
+                    } else if (strcmp(ak2, "member_expression") == 0 ||
+                               strcmp(ak2, "selector_expression") == 0 ||
+                               strcmp(ak2, "attribute") == 0 ||
+                               strcmp(ak2, "field_expression") == 0) {
+                        call.second_arg_name = cbm_node_text(ctx->arena, arg2, ctx->source);
+                    }
+                }
+            }
+
             cbm_calls_push(&ctx->result->calls, ctx->arena, call);
         }
     }

internal/cbm/service_patterns.c

@@ -282,13 +282,122 @@ static const lib_pattern_t config_libraries[] = {
     {NULL, CBM_SVC_NONE, NULL},
 };
 
-/* ── HTTP method inference from function/method name suffix ───── */
+/* Route registration frameworks — callee resolves to one of these AND
+ * has an HTTP method suffix → CBM_SVC_ROUTE_REG.
+ * Distinguished from HTTP clients: "gin.GET" registers a handler,
+ * "requests.get" makes an outbound HTTP call. */
+static const lib_pattern_t route_reg_libraries[] = {
+    /* Go */
+    {"gin-gonic/gin", CBM_SVC_ROUTE_REG, NULL},
+    {"gin.", CBM_SVC_ROUTE_REG, NULL},
+    {"go-chi/chi", CBM_SVC_ROUTE_REG, NULL},
+    {"chi.", CBM_SVC_ROUTE_REG, NULL},
+    {"gorilla/mux", CBM_SVC_ROUTE_REG, NULL},
+    {"labstack/echo", CBM_SVC_ROUTE_REG, NULL},
+    {"echo.", CBM_SVC_ROUTE_REG, NULL},
+    {"gofiber/fiber", CBM_SVC_ROUTE_REG, NULL},
+    {"fiber.", CBM_SVC_ROUTE_REG, NULL},
+    {"net/http.ServeMux", CBM_SVC_ROUTE_REG, NULL},
+    {"http.ServeMux", CBM_SVC_ROUTE_REG, NULL},
+    {"httprouter", CBM_SVC_ROUTE_REG, NULL},
+
+    /* JavaScript / TypeScript */
+    {"express", CBM_SVC_ROUTE_REG, NULL},
+    {"fastify", CBM_SVC_ROUTE_REG, NULL},
+    {"koa-router", CBM_SVC_ROUTE_REG, NULL},
+    {"hono", CBM_SVC_ROUTE_REG, NULL},
+    {"hapi", CBM_SVC_ROUTE_REG, NULL},
+
+    /* Python (non-decorator, e.g., Flask add_url_rule) */
+    {"flask", CBM_SVC_ROUTE_REG, NULL},
+    {"FastAPI", CBM_SVC_ROUTE_REG, NULL},
+    {"starlette", CBM_SVC_ROUTE_REG, NULL},
+
+    /* PHP */
+    {"Laravel", CBM_SVC_ROUTE_REG, NULL},
+    {"Illuminate.Routing", CBM_SVC_ROUTE_REG, NULL},
+    {"Symfony.Routing", CBM_SVC_ROUTE_REG, NULL},
+
+    /* Kotlin */
+    {"ktor.server", CBM_SVC_ROUTE_REG, NULL},
+    {"ktor.routing", CBM_SVC_ROUTE_REG, NULL},
+
+    /* Rust */
+    {"actix-web", CBM_SVC_ROUTE_REG, NULL},
+    {"actix_web", CBM_SVC_ROUTE_REG, NULL},
+    {"axum", CBM_SVC_ROUTE_REG, NULL},
+    {"rocket", CBM_SVC_ROUTE_REG, NULL},
+
+    /* Java */
+    {"Spring", CBM_SVC_ROUTE_REG, NULL},
+    {"jakarta.ws.rs", CBM_SVC_ROUTE_REG, NULL},
+
+    /* C# */
+    {"Microsoft.AspNetCore", CBM_SVC_ROUTE_REG, NULL},
+    {"MapGet", CBM_SVC_ROUTE_REG, NULL},
+    {"MapPost", CBM_SVC_ROUTE_REG, NULL},
+
+    /* Ruby */
+    {"ActionDispatch", CBM_SVC_ROUTE_REG, NULL},
+    {"Sinatra", CBM_SVC_ROUTE_REG, NULL},
+
+    /* Elixir */
+    {"Phoenix.Router", CBM_SVC_ROUTE_REG, NULL},
+
+    /* Scala */
+    {"akka.http.scaladsl.server", CBM_SVC_ROUTE_REG, NULL},
+    {"play.api.routing", CBM_SVC_ROUTE_REG, NULL},
 
+    {NULL, CBM_SVC_NONE, NULL},
+};
+
+/* Method suffix type (used by both route registration and HTTP client tables) */
 typedef struct {
     const char *suffix;
     const char *method;
 } method_suffix_t;
 
+/* Route registration method suffixes — matched on callee name.
+ * These are methods on router objects that register handlers. */
+static const method_suffix_t route_reg_suffixes[] = {
+    /* HTTP method registrations */
+    {".GET", "GET"},
+    {".Get", "GET"},
+    {".get", "GET"},
+    {".POST", "POST"},
+    {".Post", "POST"},
+    {".post", "POST"},
+    {".PUT", "PUT"},
+    {".Put", "PUT"},
+    {".put", "PUT"},
+    {".DELETE", "DELETE"},
+    {".Delete", "DELETE"},
+    {".delete", "DELETE"},
+    {".PATCH", "PATCH"},
+    {".Patch", "PATCH"},
+    {".patch", "PATCH"},
+    /* Handle/HandleFunc (Go stdlib, gorilla) */
+    {".Handle", "ANY"},
+    {".HandleFunc", "ANY"},
+    {".handle", "ANY"},
+    /* Framework-specific route registration */
+    {".Route", "ANY"},
+    {".route", "ANY"},
+    {"::get", "GET"},
+    {"::post", "POST"},
+    {"::put", "PUT"},
+    {"::delete", "DELETE"},
+    {"::patch", "PATCH"},
+    /* Minimal API (C# ASP.NET) */
+    {".MapGet", "GET"},
+    {".MapPost", "POST"},
+    {".MapPut", "PUT"},
+    {".MapDelete", "DELETE"},
+    {NULL, NULL},
+};
+
+/* ── HTTP method inference from function/method name suffix ───── */
+
 static const method_suffix_t method_suffixes[] = {
     {".get", "GET"},           {".Get", "GET"},           {".GET", "GET"},
     {".post", "POST"},         {".Post", "POST"},         {".POST", "POST"},
@@ -331,7 +440,14 @@ cbm_svc_kind_t cbm_service_pattern_match(const char *resolved_qn) {
         return CBM_SVC_NONE;
     }
 
-    const lib_pattern_t *p = match_qn(resolved_qn, http_libraries);
+    /* Route registration checked first — prevents gin/echo from matching
+     * as HTTP clients (both have .get/.post suffixes). */
+    const lib_pattern_t *p = match_qn(resolved_qn, route_reg_libraries);
+    if (p) {
+        return p->kind;
+    }
+
+    p = match_qn(resolved_qn, http_libraries);
     if (p) {
         return p->kind;
     }
@@ -363,6 +479,20 @@ const char *cbm_service_pattern_http_method(const char *callee_name) {
     return NULL;
 }
 
+const char *cbm_service_pattern_route_method(const char *callee_name) {
+    if (!callee_name) {
+        return NULL;
+    }
+    size_t clen = strlen(callee_name);
+    for (int i = 0; route_reg_suffixes[i].suffix != NULL; i++) {
+        size_t slen = strlen(route_reg_suffixes[i].suffix);
+        if (clen >= slen && strcmp(callee_name + clen - slen, route_reg_suffixes[i].suffix) == 0) {
+            return route_reg_suffixes[i].method;
+        }
+    }
+    return NULL;
+}
+
 const char *cbm_service_pattern_broker(const char *resolved_qn) {
     if (!resolved_qn) {
         return NULL;

internal/cbm/service_patterns.h

@@ -13,10 +13,11 @@
 
 /* Edge type returned by pattern match. */
 typedef enum {
-    CBM_SVC_NONE = 0,   /* Not a service pattern — use normal CALLS */
-    CBM_SVC_HTTP = 1,   /* Synchronous HTTP client call */
-    CBM_SVC_ASYNC = 2,  /* Async dispatch (message broker, task queue) */
-    CBM_SVC_CONFIG = 3, /* Config/env accessor */
+    CBM_SVC_NONE = 0,      /* Not a service pattern — use normal CALLS */
+    CBM_SVC_HTTP = 1,      /* Synchronous HTTP client call */
+    CBM_SVC_ASYNC = 2,     /* Async dispatch (message broker, task queue) */
+    CBM_SVC_CONFIG = 3,    /* Config/env accessor */
+    CBM_SVC_ROUTE_REG = 4, /* Route registration (router.GET, app.get, Route::post) */
 } cbm_svc_kind_t;
 
 /* Initialize the pattern lookup tables. Call once at startup. Thread-safe after init. */
@@ -32,6 +33,11 @@ cbm_svc_kind_t cbm_service_pattern_match(const char *resolved_qn);
  * Returns NULL if method cannot be inferred. */
 const char *cbm_service_pattern_http_method(const char *callee_name);
 
+/* Get the HTTP method from a route registration callee name suffix
+ * (e.g., "router.GET" → "GET", "app.post" → "POST").
+ * Returns NULL if not a known route registration method. */
+const char *cbm_service_pattern_route_method(const char *callee_name);
+
 /* Get the broker name for an async QN (e.g., "pubsub" from a Pub/Sub QN).
  * Returns NULL if not an async pattern. */
 const char *cbm_service_pattern_broker(const char *resolved_qn);

src/pipeline/pass_calls.c

@@ -275,6 +275,46 @@ int cbm_pipeline_pass_calls(cbm_pipeline_ctx_t *ctx, const cbm_file_info_t *file
             /* Classify edge type by library in resolved QN */
             cbm_svc_kind_t svc = cbm_service_pattern_match(res.qualified_name);
 
+            if (svc == CBM_SVC_ROUTE_REG && call->first_string_arg != NULL &&
+                call->first_string_arg[0] == '/') {
+                /* Route registration: router.GET("/path", handler) → Route + HANDLES */
+                const char *method = cbm_service_pattern_route_method(call->callee_name);
+                char route_qn[CBM_ROUTE_QN_SIZE];
+                snprintf(route_qn, sizeof(route_qn), "__route__%s__%s", method ? method : "ANY",
+                         call->first_string_arg);
+                char route_props[256];
+                snprintf(route_props, sizeof(route_props), "{\"method\":\"%s\"}",
+                         method ? method : "ANY");
+                int64_t route_id = cbm_gbuf_upsert_node(ctx->gbuf, "Route", call->first_string_arg,
+                                                        route_qn, "", 0, 0, route_props);
+
+                char props[512];
+                snprintf(props, sizeof(props),
+                         "{\"callee\":\"%s\",\"url_path\":\"%s\",\"via\":\"route_registration\"}",
+                         call->callee_name, call->first_string_arg);
+                cbm_gbuf_insert_edge(ctx->gbuf, source_node->id, route_id, "CALLS", props);
+
+                /* Resolve handler and create HANDLES edge */
+                if (call->second_arg_name != NULL && call->second_arg_name[0] != '\0') {
+                    cbm_resolution_t hres =
+                        cbm_registry_resolve(ctx->registry, call->second_arg_name, module_qn,
+                                             imp_keys, imp_vals, imp_count);
+                    if (hres.qualified_name != NULL && hres.qualified_name[0] != '\0') {
+                        const cbm_gbuf_node_t *handler =
+                            cbm_gbuf_find_by_qn(ctx->gbuf, hres.qualified_name);
+                        if (handler != NULL) {
+                            char hprops[256];
+                            snprintf(hprops, sizeof(hprops), "{\"handler\":\"%s\"}",
+                                     hres.qualified_name);
+                            cbm_gbuf_insert_edge(ctx->gbuf, handler->id, route_id, "HANDLES",
+                                                 hprops);
+                        }
+                    }
+                }
+                resolved++;
+                continue;
+            }
+
             if (svc == CBM_SVC_HTTP || svc == CBM_SVC_ASYNC) {
                 /* HTTP/async call — route through Route node for cross-service traversal.
                  * Only create Route if string looks like a URL (HTTP) or topic name (async). */