Never resolve free variables as types during overload ordering

[HertzDevil]

In the following snippet, the Bar in x : Bar is resolved as a type even though it is a free variable, and since Bar < Foo, the Bar overload is ordered first:

class Foo; end
class Bar < Foo; end

def foo(x : Foo); 1; end
def foo(x : Bar) forall Bar; end

foo(Foo.new) # => nil

Bar forall Bar accepts types that are not subtypes of Foo, so the overload order should be untouched here.

Similarly, in the following snippet, the two defs are redefinitions because the restrictions have the same name, even though only one of them is a free variable and the two are definitely distinguishable:

class Foo; end

def foo(x : Foo) forall Foo; end
def foo(x : Foo); end

foo(3) # Error: no overload matches 'foo' with type Int32

This PR makes it so that those free variables are never resolved as types; for the purposes of overload ordering, they are considered undefined types, and the non-free Paths come first. Most free variables have only one letter and most type names don't, so the impact should be very small in practice.

The first commit here is also necessary when we eventually deal with bounded free variables.

Nothing changes if both Paths are free variables (they are already somewhat broken before and nobody really knows how to fix them yet, for example #10042).