False positive recursive alias during overload ordering

[HertzDevil]

The following code reports an improper recursive alias even though there are none:

class Foo1; end
class Foo2 < Foo1; end
class Foo3 < Foo1; end

class Foo1
  alias Bar = Foo2::Bar | Foo3::Bar # Error: infinite recursive definition of alias Foo1::Bar
end

class Foo2 < Foo1
  class Bar; end
  def foo(other : Foo1::Bar); end
  def foo(other : String); end
end

class Foo3 < Foo1
  class Bar; end
end

It happens because the overloads of Foo2#foo need to be ordered, and in doing so the compiler looks up Foo1::Bar's definition as soon as the String overload is defined. At this point, Foo3 is indeed defined, and it inherits constants from Foo1, so Foo3::Bar is exactly Foo1::Bar, which explains why Foo1::Bar refers to itself. Similarly, an "undefined constant" error can be triggered this way by not forward declaring any types:

class Foo1
  alias Bar = Foo2::Bar | Foo3::Bar # Error: undefined constant Foo3::Bar
end

class Foo2 < Foo1
  class Bar; end
  def foo(other : Foo1::Bar); end # okay, `Foo1` is defined up to this point
  def foo(other : String); end
end

class Foo3 < Foo1
  class Bar; end
end

I discovered this while trying to do this seemingly harmless refactor:

# src/float.cr

struct Float64
  # `Foo1::Bar` corresponds to `Number::Primitive`
  # note that primitive number types are forward declared by the compiler itself
  Number.expand_div [Int::Primitive], Float64
  Number.expand_div [Float32], Float64
end

A workaround is to also forward declare Bar1 before any methods are defined. On the other hand, making these examples work means that the compiler has to defer overload ordering to a later stage (contrast with #4897); resolving the aliases "beforehand" is not enough, because both aliases and defs are declared as they are read during the top-level phase.

[HertzDevil]

Here is another variant also triggered by the inheritance of namespaced constants:

class Foo1
  class Bar; end
end

class Foo2 < Foo1; end

def foo(x : Foo1::Bar); end
def foo(x : Foo2::Bar); end
# at this point `Foo2::Bar` is identical to `Foo1::Bar`, so this is a
# redefinition and the first overload disappears

class Foo2::Bar; end

foo(Foo1::Bar.new) # Error: no overload matches 'foo' with type Foo1::Bar