Provide resolution diagnostics

[Morriar]

Please review #472 and #473 first.

Closes #435.

Introduce 6 new diagnostics:

• KindRedefinition: redefining a class as a module or vice versa
• ParentRedefinition: redefining the parent of a class
• NonClassSuperclass: subclassing something that is not a class
• CircularDependency: introducing a mixin or parent class cycle
• NonModuleMixin: including something that is not a module
• UnresolvedConstantReference: using a constant that can't be resolved

[vinistock]

Instead of looping through the entire list, I think we can just add diagnostics directly to anything that's still in the unit_queue, no?

Whatever is left is what we failed to resolve.

[vinistock]

For both of the mixin diagnostics, are we not able to add them during linearization to avoid looping afterwards?

[vinistock]

I don't think we can just compare that they're not the same. For example, this is valid code:

Foo = Struct.new

class Foo
  include Bar
end

I was looking into this specific case as part of the struct work and I believe we need these checks (or maybe some of them) in Graph#add_declaration, so that we can auto-promote certain declaration cases like the one in this example.

Another valid case is having a method declaration that has two definitions: one method and one attribute.

[Morriar]

The trick is in from_definition_kind where we map the output definition kind to declaration kind:

   pub fn from_definition_kind(definition_kind: DefinitionKind) -> Self {
        match definition_kind {
            DefinitionKind::Class => DeclarationKind::Class,
            DefinitionKind::SingletonClass => DeclarationKind::SingletonClass,
            DefinitionKind::Module => DeclarationKind::Module,
            DefinitionKind::Constant => DeclarationKind::Constant,
            DefinitionKind::ConstantAlias => DeclarationKind::ConstantAlias,
            DefinitionKind::Method
            | DefinitionKind::MethodAlias
            | DefinitionKind::AttrAccessor
            | DefinitionKind::AttrReader
            | DefinitionKind::AttrWriter => DeclarationKind::Method,
            DefinitionKind::InstanceVariable => DeclarationKind::InstanceVariable,
            DefinitionKind::ClassVariable => DeclarationKind::ClassVariable,
            DefinitionKind::GlobalVariable | DefinitionKind::GlobalVariableAlias => DeclarationKind::GlobalVariable,

So both an attr accessor and a method definition map to a method declaration so this is correct:

def foo; end
attr_reader :foo

For Struct, this would be the same:

 match definition_kind {
            DefinitionKind::Class | DefinitionKind::Struct => DeclarationKind::Class,

[Morriar]

@vinistock I pushed another PR #502 to show what it would look like to compute the diagnostics during the resolution rather than after.

TL;DR: it's not faster but more invasive and complex.