fix(native): compute complexity/cfg for prototype method definitions

`emit_js_prototype_method` and `extract_js_prototype_object_literal`
were emitting `complexity: None` / `cfg: None` for every function-
expression and method_definition RHS, unlike every other method/
function handler in the Rust extractor.

Call `compute_all_metrics` and `build_function_cfg` at both sites.
Add assertions to the 3 affected prototype unit tests to guard this.

Closes #1340

Author: carlos-alm

crates/codegraph-core/src/extractors/javascript.rs

@@ -368,8 +368,8 @@ fn emit_js_prototype_method(class_name: &str, method_name: &str, rhs: &Node, sou
                 line: start_line(rhs),
                 end_line: Some(end_line(rhs)),
                 decorators: None,
-                complexity: None,
-                cfg: None,
+                complexity: compute_all_metrics(rhs, source, "javascript"),
+                cfg: build_function_cfg(rhs, "javascript", source),
                 children: None,
             });
         }
@@ -398,8 +398,8 @@ fn extract_js_prototype_object_literal(class_name: &str, obj_node: &Node, source
                     line: start_line(&child),
                     end_line: Some(end_line(&child)),
                     decorators: None,
-                    complexity: None,
-                    cfg: None,
+                    complexity: compute_all_metrics(&child, source, "javascript"),
+                    cfg: build_function_cfg(&child, "javascript", source),
                     children: None,
                 });
             }
@@ -2448,7 +2448,10 @@ mod tests {
         );
         let def = s.definitions.iter().find(|d| d.name == "C.foo");
         assert!(def.is_some(), "C.foo definition missing; got: {:?}", s.definitions.iter().map(|d| &d.name).collect::<Vec<_>>());
-        assert_eq!(def.unwrap().kind, "method");
+        let def = def.unwrap();
+        assert_eq!(def.kind, "method");
+        assert!(def.complexity.is_some(), "C.foo should have complexity metrics");
+        assert!(def.cfg.is_some(), "C.foo should have a CFG");
     }
 
     #[test]
@@ -2475,7 +2478,10 @@ mod tests {
         let foo = s.definitions.iter().find(|d| d.name == "C.foo");
         let bar = s.definitions.iter().find(|d| d.name == "C.bar");
         assert!(foo.is_some(), "C.foo missing");
-        assert_eq!(foo.unwrap().kind, "method");
+        let foo = foo.unwrap();
+        assert_eq!(foo.kind, "method");
+        assert!(foo.complexity.is_some(), "C.foo should have complexity metrics");
+        assert!(foo.cfg.is_some(), "C.foo should have a CFG");
         assert!(bar.is_some(), "C.bar missing");
     }
 
@@ -2489,7 +2495,10 @@ mod tests {
         );
         let def = s.definitions.iter().find(|d| d.name == "C.greet");
         assert!(def.is_some(), "C.greet definition missing; got: {:?}", s.definitions.iter().map(|d| &d.name).collect::<Vec<_>>());
-        assert_eq!(def.unwrap().kind, "method");
+        let def = def.unwrap();
+        assert_eq!(def.kind, "method");
+        assert!(def.complexity.is_some(), "C.greet should have complexity metrics");
+        assert!(def.cfg.is_some(), "C.greet should have a CFG");
     }
 
     #[test]