Defer cleanup of emptied and synthetic declarations during invalidation

During invalidation, declarations can lose all of their backing definitions before the resolver has a chance to recreate them. Queue those declarations for post-resolution cleanup instead of removing them immediately.

The cleanup pass now preserves TODO namespaces that still have members, reaps orphaned singleton classes once their members and attached references are gone, re-queues owners that become empty when a child is removed, and loops resolution until cleanup stops producing more work.

Also fix remove_document_data so deleting an attached reference like Foo.new detaches the stale singleton reference even if the attached name was already unresolved, and add incremental regression tests for the affected delete, delete-and-readd, and compact-notation cleanup cases.

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.as_ref() == Some(expected) {
+                    self.singleton_class_id = None;
+                }
+            }
+
             pub fn singleton_class_id(&self) -> Option<&DeclarationId> {
                 self.singleton_class_id.as_ref()
             }
@@ -345,6 +353,27 @@ 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. Bootstrap declarations (Object, Module, Class) are never
+    /// removable. Singleton classes are only removable when they have no
+    /// definitions AND no members — populated singletons serve as namespace
+    /// parents for class-level methods.
+    #[must_use]
+    pub fn has_no_backing_definitions(&self, decl_id: &DeclarationId) -> bool {
+        if *decl_id == *super::graph::OBJECT_ID
+            || *decl_id == *super::graph::MODULE_ID
+            || *decl_id == *super::graph::CLASS_ID
+        {
+            return false;
+        }
+
+        if matches!(self, Declaration::Namespace(Namespace::SingletonClass(_))) {
+            return self.has_no_definitions() && self.as_namespace().is_some_and(|ns| ns.members().is_empty());
+        }
+
+        self.has_no_definitions()
+    }
+
     pub fn add_definition(&mut self, definition_id: DefinitionId) {
         all_declarations!(self, it => {
             debug_assert!(
@@ -578,6 +607,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)