Defer cleanup of emptied and synthetic declarations during invalidation

After incremental invalidation, declarations can lose all their
definitions. Previously these were removed immediately, destroying
accumulated state (singleton links, member lists) the resolver needs.

This defers TODO cleanup to after resolution via `cleanup_stale_todos()`.
TODOs created speculatively by `create_todo_for_parent` are marked via
`defer_todo_cleanup` and evaluated post-resolution — promoted TODOs and
those with members are kept, empty stubs are removed.

Singleton classes use references and members as "still in use" signals
in `has_no_backing_definitions`, preventing premature removal when
callers (Foo.new) or class-level state (@x = 1) still exist.

Other empty declarations (from file deletion or member removal) cascade
immediately via the invalidation worklist.

Author: st0012

rust/rubydex/src/model/declaration.rs

@@ -162,6 +162,14 @@ macro_rules! namespace_declaration {
                 self.singleton_class_id = Some(declaration_id);
             }
 
+            /// Clears `singleton_class_id` only if it matches `expected`.
+            /// Prevents accidentally clearing a pointer to a re-created singleton.
+            pub fn clear_singleton_class_id(&mut self, expected: DeclarationId) {
+                if self.singleton_class_id == Some(expected) {
+                    self.singleton_class_id = None;
+                }
+            }
+
             pub fn singleton_class_id(&self) -> Option<&DeclarationId> {
                 self.singleton_class_id.as_ref()
             }
@@ -327,6 +335,14 @@ impl Declaration {
         }
     }
 
+    #[must_use]
+    pub fn as_singleton_class(&self) -> Option<&Namespace> {
+        match self {
+            Declaration::Namespace(ns @ Namespace::SingletonClass(_)) => Some(ns),
+            _ => None,
+        }
+    }
+
     #[must_use]
     pub fn as_namespace_mut(&mut self) -> Option<&mut Namespace> {
         match self {
@@ -345,6 +361,19 @@ impl Declaration {
         all_declarations!(self, it => it.definition_ids.is_empty())
     }
 
+    /// Returns true if this declaration has no backing definitions and is eligible
+    /// for removal. Singleton classes are only removable when they have no
+    /// definitions, no members, and no constant references — any of these
+    /// signals means the singleton is still in use.
+    #[must_use]
+    pub fn has_no_backing_definitions(&self) -> bool {
+        if let Some(singleton_class) = self.as_singleton_class() {
+            return singleton_class.is_empty() && singleton_class.references().is_empty();
+        }
+
+        self.has_no_definitions()
+    }
+
     pub fn add_definition(&mut self, definition_id: DefinitionId) {
         all_declarations!(self, it => {
             debug_assert!(
@@ -466,6 +495,12 @@ impl Namespace {
         }
     }
 
+    /// Returns true if this namespace has no definitions and no members.
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        all_namespaces!(self, it => it.definition_ids.is_empty() && it.members.is_empty())
+    }
+
     #[must_use]
     pub fn references(&self) -> &IdentityHashSet<ConstantReferenceId> {
         all_namespaces!(self, it => &it.references)
@@ -578,6 +613,10 @@ impl Namespace {
         all_namespaces!(self, it => it.set_singleton_class_id(declaration_id));
     }
 
+    pub fn clear_singleton_class_id(&mut self, expected: DeclarationId) {
+        all_namespaces!(self, it => it.clear_singleton_class_id(expected));
+    }
+
     #[must_use]
     pub fn owner_id(&self) -> &DeclarationId {
         all_namespaces!(self, it => &it.owner_id)