Add incremental invalidation engine (#641)

Replaces the old `remove_definitions_for_document` +
`invalidate_ancestor_chains` approach with a targeted invalidation
engine. When a file is updated or deleted, the engine traces through the
`name_dependents` reverse index to invalidate only the affected
declarations, names, and references — instead of requiring a full graph
rebuild.

## How it works

`consume_document_changes()` (renamed from `update()`) and
`delete_document()` run a three-step pipeline:

1. **`invalidate`** — read-only scan that seeds a worklist from old/new
definitions and references, building a `pending_detachments` side table
for definitions that need to be detached from their declarations
2. **`remove_document_data`** — cleans up phase 1 data (definitions,
references, names, strings) from maps
3. **`extend`** — merges new content and queues work items for the
resolver

The resolver still does `clear_declarations` + full rebuild. Wiring it
to drain `pending_work` incrementally is a follow-up.

### Invalidation worklist

The worklist processes three item types:

- **`Declaration`** — two modes:
- *Remove*: no definitions remain or owner was already removed
(orphaned). Cascades to members, singleton class, and descendants.
Orphaned definitions are re-queued for re-resolution (e.g. `class
Foo::Bar` survives even if `Foo` changes from a module to an alias).
- *Update*: declaration survives but its ancestor chain may have changed
(mixin added/removed, superclass changed). Clears ancestors/descendants
and re-queues ancestor resolution.
- **`Name`** — structural dependency broken (name's nesting or parent
scope removed). Unresolves the name and cascades to all dependents.
- **`References`** — ancestor context changed, but the name itself is
still valid. Needed for mixin-related invalidation:

```ruby
class Foo < Bar
  CONST
end

# Another file adds:
class Foo
  include Baz # Foo's ancestors changed, so references like CONST need re-evaluation
end
```

### Cascade differentiation

The `name_dependents` reverse index distinguishes `ChildName` (compact
syntax `Foo::Bar`) from `NestedName` (nested syntax `module Foo; class
Bar; end; end`):

- **Structural cascade** (name removed): both `ChildName` and
`NestedName` → `Name`
- **Ancestor-triggered cascade** (mixin changed): `ChildName` → `Name`
(resolves through parent), `NestedName` → `References` (only references
need rechecking)

Author: st0012

rust/rubydex-sys/src/graph_api.rs

@@ -643,7 +643,7 @@ mod tests {
         indexer.index();
 
         let mut graph = Graph::new();
-        graph.update(indexer.local_graph());
+        graph.consume_document_changes(indexer.local_graph());
         let mut resolver = Resolver::new(&mut graph);
         resolver.resolve_all();
 

rust/rubydex/src/indexing.rs

@@ -95,7 +95,7 @@ impl Job for IndexingJob {
 /// Indexes a single source string in memory, dispatching to the appropriate indexer based on `language_id`.
 pub fn index_source(graph: &mut Graph, uri: &str, source: &str, language_id: &LanguageId) {
     let local_graph = build_local_graph(uri.to_string(), source, language_id);
-    graph.update(local_graph);
+    graph.consume_document_changes(local_graph);
 }
 
 /// Indexes the given paths, reading the content from disk and populating the given `Graph` instance.
@@ -123,7 +123,7 @@ pub fn index_files(graph: &mut Graph, paths: Vec<PathBuf>) -> Vec<Errors> {
 
     // Merge graphs as they arrive, overlapping with indexing work on other threads.
     while let Ok(local_graph) = local_graphs_rx.recv() {
-        graph.update(local_graph);
+        graph.consume_document_changes(local_graph);
     }
 
     for handle in handles {

rust/rubydex/src/model/declaration.rs

@@ -482,6 +482,10 @@ impl Namespace {
         all_namespaces!(self, it => it.member(str_id))
     }
 
+    pub fn remove_member(&mut self, str_id: &StringId) -> Option<DeclarationId> {
+        all_namespaces!(self, it => it.remove_member(str_id))
+    }
+
     #[must_use]
     pub fn singleton_class(&self) -> Option<&DeclarationId> {
         all_namespaces!(self, it => it.singleton_class_id())