Fix several compile-time operations on generic instance metaclasses

[HertzDevil]

An assortment of fixes that improve the correctness of generic instance metaclass types (e.g. Array(Int32).class, Enumerable(String).class).

• Disallows T.class.class as a distinct type when T is a generic instance. The same type expression will produce Class just like other kinds of metaclasses.
• Gives proper superclasses to the metaclasses of generic class instances. This is reflected by TypeNode#superclass, where the same code would currently produce nil twice: (#ancestors already worked correctly prior to this PR)

  class Foo(T); end
  class Bar(T) < Foo(T); end
  
  {% Foo(Int32).class.superclass %} # => Reference.class
  {% Bar(Int32).class.superclass %} # => Foo(Int32).class

• Makes it so that T.class <= U.class if and only if T <= U. Previously this was not computed properly when either type is a generic instance; T.class was regarded as a normal type in Crystal::Type#implements?, so it completely ignored subtyping due to generics, causing the following lines to produce false:

  {% Bar(Int32).class < Bar.class %} # => true
  {% Bar(Int32).class < Foo.class %} # => true
  {% Bar.class < Foo.class %}        # => true
  
  # If `Foo(T)` were a module and included by `Bar(T)`, even the following
  # would currently produce `false`
  {% Bar(Int32).class < Foo(Int32).class %} # => true

• Makes it so that T.class < U.class if T inherits from U (module inclusion does not count), or if T is a generic instance of U. Previously this was not computed properly when either type is a generic instance; T.class was regarded as a normal type in Crystal::Type#implements?, so it completely ignored subtyping due to generics, causing the following lines to produce false:

  {% Bar(Int32).class < Bar.class %} # => true
  {% Bar(Int32).class < Foo.class %} # => true
  {% Bar.class < Foo.class %}        # => true

Does not affect #11068. Also does not affect Class#<= (subtyping comparisons between runtime metaclasses).

[HertzDevil]

For #11110 this will fix the subtyping check, but the ancestors of generic module instance metaclasses will still include Object.class:

module Foo(T); end

{% Foo(Int32).class <= Object.class %} # => false
{% Foo(Int32).class.ancestors %}       # => [Object.class, Class, Value, Object]

[HertzDevil]

It seems we copied Ruby for not introducing a subtyping relation between T.class and U.class when T includes the module U (see #11119), so 12cdcc6 is replaced by 0b5ac18.

[asterite]

Looks great, thank you!