feat(extraction): C# delegate/event handler call resolution

Three fixes for C# delegate and event subscription patterns that were
invisible to the call graph:

Fix 1 — Bare method reference subscription:
  event += MethodName creates a CALLS edge from the subscribing method
  to the handler. Detects assignment_expression with += operator where
  the RHS is an identifier or member_access_expression.
  e.g. socket.OnConnected += SocketOnConnected

Fix 2 — Delegate .Invoke() resolution:
  delegate?.Invoke(args) resolved to 'Invoke' which matches nothing.
  Now detects conditional_access_expression and member_access_expression
  where the method is 'Invoke', extracts the receiver (delegate property)
  name as the call target instead.
  e.g. OnConnected?.Invoke(this, e) → CALLS edge to 'OnConnected'

Fix 3 — Lambda event body scope attribution:
  Lambda expressions inside += assignments no longer create a new scope
  boundary. Calls inside the lambda body are attributed to the enclosing
  method that subscribes the event, not to an anonymous lambda scope.
  This means all handler logic is correctly attributed to the method
  that registers the event subscription.
  e.g. socket.OnError += (s, e) => { ErrorOnce(...); } attributes
  the ErrorOnce call to the method containing the += statement.

Tested on C# codebase: SocketOnConnected gained 1 incoming caller
(from += subscription) and 1 outgoing call (from ?.Invoke resolution).
InitializeExternalClient gained 10 additional outgoing calls from
lambda body attribution (30 total, up from 20).

Author: Your Name

internal/cbm/extract_calls.c

@@ -344,4 +344,101 @@ void handle_calls(CBMExtractCtx *ctx, TSNode node, const CBMLangSpec *spec, Walk
             }
         }
     }
+
+    // C# delegate/event patterns
+    if (ctx->language == CBM_LANG_CSHARP) {
+        // Fix 1: event += MethodName (bare method reference subscription)
+        // Creates a CALLS edge from the subscribing method to the handler method.
+        // e.g. _socket.OnConnected += SocketOnConnected;
+        if (strcmp(kind, "assignment_expression") == 0) {
+            TSNode op = ts_node_child_by_field_name(node, "operator", 8);
+            if (!ts_node_is_null(op)) {
+                char *op_text = cbm_node_text(ctx->arena, op, ctx->source);
+                if (op_text && strcmp(op_text, "+=") == 0) {
+                    TSNode right = ts_node_child_by_field_name(node, "right", 5);
+                    if (!ts_node_is_null(right)) {
+                        const char *rk = ts_node_type(right);
+                        if (strcmp(rk, "identifier") == 0 ||
+                            strcmp(rk, "member_access_expression") == 0) {
+                            char *callee = cbm_node_text(ctx->arena, right, ctx->source);
+                            if (callee && callee[0] && !cbm_is_keyword(callee, ctx->language)) {
+                                CBMCall call;
+                                call.callee_name = callee;
+                                call.enclosing_func_qn = state->enclosing_func_qn;
+                                cbm_calls_push(&ctx->result->calls, ctx->arena, call);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // Fix 2: delegate?.Invoke() → resolve to receiver (delegate) name.
+        // C# delegates are invoked via .Invoke() or ?.Invoke() — the callee name
+        // "Invoke" resolves to nothing. Instead, extract the receiver (delegate property)
+        // name, which is more likely to match a registered symbol.
+        // e.g. OnConnected?.Invoke(this, e) → creates CALLS edge to "OnConnected"
+        //
+        // C# tree-sitter AST for "OnConnected?.Invoke(this, e)":
+        //   invocation_expression
+        //     function: conditional_access_expression
+        //       expression: identifier "OnConnected"    ← receiver
+        //       member_binding_expression
+        //         name: identifier "Invoke"              ← method
+        //     arguments: argument_list
+        if (cbm_kind_in_set(node, spec->call_node_types)) {
+            TSNode func_node2 = ts_node_child_by_field_name(node, "function", 8);
+            if (!ts_node_is_null(func_node2)) {
+                const char *fk2 = ts_node_type(func_node2);
+                bool is_invoke = false;
+                TSNode receiver2 = {0}; // NOLINT
+
+                if (strcmp(fk2, "conditional_access_expression") == 0) {
+                    // ?. access: look for member_binding_expression child
+                    uint32_t ncc = ts_node_named_child_count(func_node2);
+                    for (uint32_t ci = 0; ci < ncc; ci++) {
+                        TSNode child = ts_node_named_child(func_node2, ci);
+                        const char *ck = ts_node_type(child);
+                        if (strcmp(ck, "member_binding_expression") == 0) {
+                            TSNode name_n = ts_node_child_by_field_name(child, "name", 4);
+                            if (!ts_node_is_null(name_n)) {
+                                char *nm = cbm_node_text(ctx->arena, name_n, ctx->source);
+                                if (nm && strcmp(nm, "Invoke") == 0) {
+                                    is_invoke = true;
+                                }
+                            }
+                        }
+                        if (strcmp(ck, "identifier") == 0 ||
+                            strcmp(ck, "member_access_expression") == 0) {
+                            receiver2 = child;
+                        }
+                    }
+                } else if (strcmp(fk2, "member_access_expression") == 0) {
+                    // Dot access: obj.Invoke(...)
+                    TSNode name_n = ts_node_child_by_field_name(func_node2, "name", 4);
+                    if (!ts_node_is_null(name_n)) {
+                        char *nm = cbm_node_text(ctx->arena, name_n, ctx->source);
+                        if (nm && strcmp(nm, "Invoke") == 0) {
+                            is_invoke = true;
+                            TSNode expr = ts_node_child_by_field_name(func_node2,
+                                                                      "expression", 10);
+                            if (!ts_node_is_null(expr)) {
+                                receiver2 = expr;
+                            }
+                        }
+                    }
+                }
+
+                if (is_invoke && !ts_node_is_null(receiver2)) {
+                    char *recv = cbm_node_text(ctx->arena, receiver2, ctx->source);
+                    if (recv && recv[0] && !cbm_is_keyword(recv, ctx->language)) {
+                        CBMCall call;
+                        call.callee_name = recv;
+                        call.enclosing_func_qn = state->enclosing_func_qn;
+                        cbm_calls_push(&ctx->result->calls, ctx->arena, call);
+                    }
+                }
+            }
+        }
+    }
 }

internal/cbm/extract_unified.c

@@ -153,9 +153,32 @@ void cbm_extract_unified(CBMExtractCtx *ctx) {
 
         // 4. Push scope markers for boundary nodes
         if (spec->function_node_types && cbm_kind_in_set(node, spec->function_node_types)) {
-            const char *fqn = compute_func_qn(ctx, node, spec, &state);
-            if (fqn) {
-                push_scope(&state, SCOPE_FUNC, depth, fqn);
+            // Fix 3: C# lambda_expression inside += assignment should NOT create
+            // a new scope boundary. Calls inside the lambda body should be attributed
+            // to the outer method that subscribes the event handler, not to an
+            // anonymous lambda. This matches the semantic intent: the subscribing
+            // method IS responsible for what runs when the event fires.
+            bool skip_scope = false;
+            if (ctx->language == CBM_LANG_CSHARP &&
+                strcmp(ts_node_type(node), "lambda_expression") == 0) {
+                TSNode parent = ts_node_parent(node);
+                if (!ts_node_is_null(parent) &&
+                    strcmp(ts_node_type(parent), "assignment_expression") == 0) {
+                    TSNode op = ts_node_child_by_field_name(parent, "operator", 8);
+                    if (!ts_node_is_null(op)) {
+                        char *op_text = cbm_node_text(ctx->arena, op, ctx->source);
+                        if (op_text && (strcmp(op_text, "+=") == 0 ||
+                                        strcmp(op_text, "-=") == 0)) {
+                            skip_scope = true;
+                        }
+                    }
+                }
+            }
+            if (!skip_scope) {
+                const char *fqn = compute_func_qn(ctx, node, spec, &state);
+                if (fqn) {
+                    push_scope(&state, SCOPE_FUNC, depth, fqn);
+                }
             }
         } else if (spec->class_node_types && cbm_kind_in_set(node, spec->class_node_types)) {
             const char *cqn = compute_class_qn(ctx, node);