feat(native): port full-build structure computation to Rust (#937)

* feat(native): port full-build structure computation to Rust

The native Rust orchestrator only handled the small-incremental fast
path for structure computation. Full builds and large incremental
builds fell back to JS, requiring a DB round-trip through
reconstructFileSymbolsFromDb() to reload all nodes.

Add build_full_structure() to the Rust structure module that handles:
- Cleanup of previous structure data (scoped for incremental)
- Directory node insertion from discovered dirs + file paths
- Contains edges (dir→file, parent→child)
- File metrics (line count, symbol count, imports, exports, fan-in/out)
- Directory metrics (file count, symbol count, fan-in/out, cohesion)

Set structure_handled=true unconditionally so the JS fallback path
is never triggered for structure computation.

Closes #935

* fix(structure): load all file paths from DB in incremental mode (#937)

The incremental path of build_full_structure deleted all contains edges
from affected directories but only re-inserted edges for files in the
partial file_symbols set. Unchanged files in those directories
permanently lost their dir->file containment edges until the next full
rebuild. Directory metrics (file_count, symbol_count, cohesion) were
also undercounted for the same reason.

Fix: load existing file nodes from DB for affected directories before
re-inserting contains edges and computing directory metrics, ensuring
unchanged files retain their structural relationships.

Impact: 3 functions changed, 2 affected

* fix(build): remove dead structure_scope field (#937)

Since structure_handled is now unconditionally true, the JS structure
fallback never runs and structure_scope is never read. Remove the field
from BuildPipelineResult and the corresponding JS type/usage.

Impact: 2 functions changed, 5 affected

* fix(structure): restore dir->dir containment edges for unchanged sibling subdirs (#937)

During large-incremental builds, cleanup_previous_data deletes all
contains edges from affected ancestor directories. The dir->dir edge
loop only iterated over all_dirs (ancestors of changed files), so
unchanged sibling subdirectories lost their parent->child edges
permanently until the next full rebuild.

Add load_child_dirs_in_affected() to query existing directory nodes
from the DB whose parent is in the affected set, and re-insert their
containment edges after the main dir->dir loop completes.

Impact: 2 functions changed, 2 affected

Author: carlos-alm

crates/codegraph-core/src/build_pipeline.rs

@@ -72,15 +72,9 @@ pub struct BuildPipelineResult {
     pub changed_count: usize,
     pub removed_count: usize,
     pub is_full_build: bool,
-    /// Full set of changed files including reverse-dep files. Used by the JS
-    /// structure fallback path so it can update metrics for files whose edges
-    /// changed even though their content didn't. `None` for full builds.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub structure_scope: Option<Vec<String>>,
     /// Whether the Rust pipeline handled the structure phase (directory nodes,
-    /// contains edges, file metrics). True when the small-incremental fast path
-    /// ran (≤5 changed files, >20 existing files). When false, the JS caller
-    /// must run its own structure phase as a post-processing step.
+    /// contains edges, file and directory metrics). Always true — the Rust
+    /// pipeline handles both the small-incremental fast path and full builds.
     pub structure_handled: bool,
     /// Whether the Rust pipeline wrote AST/complexity/CFG/dataflow to the DB.
     /// When true, the JS caller can skip `runPostNativeAnalysis` entirely.
@@ -181,7 +175,6 @@ pub fn run_pipeline(
             changed_count: 0,
             removed_count: 0,
             is_full_build: false,
-            structure_scope: Some(vec![]),
             structure_handled: true,
             analysis_complete: true,
         });
@@ -373,11 +366,22 @@ pub fn run_pipeline(
             &line_count_map,
             &file_symbols,
         );
+    } else {
+        // Full structure: directory nodes, contains edges, file + directory metrics.
+        let changed_for_structure: Option<Vec<String>> = if change_result.is_full_build {
+            None
+        } else {
+            Some(changed_files.clone())
+        };
+        structure::build_full_structure(
+            conn,
+            &file_symbols,
+            &collect_result.directories,
+            root_dir,
+            &line_count_map,
+            changed_for_structure.as_deref(),
+        );
     }
-    // For full/larger builds, the JS fallback handles full structure via
-    // `features/structure.ts`. The Rust orchestrator handles the fast path
-    // for small incremental builds. Full structure computation will be
-    // ported in a follow-up.
     timing.structure_ms = t0.elapsed().as_secs_f64() * 1000.0;
 
     let t0 = Instant::now();
@@ -489,8 +493,7 @@ pub fn run_pipeline(
         changed_count: parse_changes.len(),
         removed_count: change_result.removed.len(),
         is_full_build: change_result.is_full_build,
-        structure_scope: changed_file_list.clone(),
-        structure_handled: use_fast_path,
+        structure_handled: true,
         analysis_complete: do_analysis && analysis_ok,
     })
 }