Fix two alias-handling issues found in review

* update_aliases persisted const.is_alias_for from the lazy
  resolved_alias_target lookup before the collision guard ran. When
  a real class already lived at the destination, the alias copy was
  correctly skipped but the constant was still mismarked, so
  Stats#report_constants and Constant#marshal_dump observed the
  alias relationship for an object the guard had just protected.
  Move the persistence below the guard so skipped aliases also skip
  the persistence.

* In the prism parser, add_constant resolved owner/name from the
  full constant path but called @container.add_module_alias on the
  outer lexical container. For Outer::Foo = Bar parsed at top level,
  this registered the alias copy as classes_hash['Foo'] (using the
  container's child_name) instead of 'Outer::Foo', leaving a stray
  top-level entry that update_aliases later duplicated under the
  correct namespace. Call owner.add_module_alias instead. The
  ripper parser already handles this correctly because parse_constant
  reassigns its container to the resolved nested module.

Tests:
* test_constant_alias_collision_does_not_mismark_constant_as_alias
  asserts Foo's constant ends up with is_alias_for=nil when a real
  Foo class already exists alongside Foo = Bar.
* test_qualified_constant_alias_registers_in_owner_namespace
  asserts Outer::Foo = Bar registers only at classes_hash['Outer::Foo']
  and does not leak a top-level Foo entry.

Author: claude

lib/rdoc/code_object/class_module.rb

@@ -848,13 +848,7 @@ def type
   def update_aliases
     constants.each do |const|
       cm = const.is_alias_for
-      if !cm && const.is_a?(RDoc::Constant)
-        cm = const.resolved_alias_target
-        # Persist the forward-reference resolution on the source constant
-        # so Stats#report_constants and Constant#marshal_dump observe the
-        # alias relationship that the lazy lookup found.
-        const.is_alias_for = cm if cm
-      end
+      cm ||= const.resolved_alias_target if const.is_a?(RDoc::Constant)
       next unless cm
 
       # Resolve chained aliases (A = B = C) to the real class/module.
@@ -882,6 +876,11 @@ def update_aliases
       existing = @store.find_class_or_module(cm_alias.full_name)
       next if existing && !existing.is_alias_for
 
+      # Persist a lazy-resolved target so Stats#report_constants and
+      # Constant#marshal_dump observe the alias relationship. Skipped
+      # aliases (above) intentionally leave the constant unmarked.
+      const.is_alias_for ||= cm
+
       cm_alias.aliases.clear
       cm_alias.is_alias_for = cm
 

lib/rdoc/parser/prism_ruby.rb

@@ -790,7 +790,7 @@ def add_constant(constant_name, rhs_name, start_line, end_line, alias_path: nil)
         @store.find_class_or_module(full_name)
       end
     if mod && constant.document_self
-      a = @container.add_module_alias(mod, alias_path, constant, @top_level)
+      a = owner.add_module_alias(mod, alias_path, constant, @top_level)
       a.store = @store
       a.line = start_line
       record_location(a)

test/rdoc/parser/prism_ruby_test.rb

@@ -1828,6 +1828,39 @@ def shim_method; end
     assert_empty bar_foo.aliases
   end
 
+  def test_constant_alias_collision_does_not_mismark_constant_as_alias
+    util_parser <<~RUBY
+      class Foo
+        def real_method; end
+      end
+      class Bar
+        def other_method; end
+      end
+      Foo = Bar
+    RUBY
+    @store.complete(:public)
+    foo_const = @store.classes_hash['Object'].find_constant_named('Foo')
+    refute_nil foo_const
+    assert_nil foo_const.is_alias_for, 'collision-skipped alias must not persist is_alias_for'
+  end
+
+  def test_qualified_constant_alias_registers_in_owner_namespace
+    util_parser <<~RUBY
+      class Bar
+        def bar_method; end
+      end
+      module Outer
+      end
+      Outer::Foo = Bar
+    RUBY
+    @store.complete(:public)
+    outer_foo = @store.classes_hash['Outer::Foo']
+    refute_nil outer_foo, 'Outer::Foo should be registered'
+    refute_nil outer_foo.is_alias_for
+    assert_equal 'Bar', outer_foo.is_alias_for.full_name
+    assert_nil @store.classes_hash['Foo'], 'qualified alias should not leak into top-level namespace'
+  end
+
   def test_constant_alias_then_class_reopen_keeps_added_methods
     util_parser <<~RUBY
       class Bar