Issue Description:

If you attempt to get the type of an unbound generic type, using Swift's built-in `type(of: )` function, the type solver doesn't produce as meaningful errors as it is able to do in some other contexts.

For instance, if you write:

struct Foo<T> {
  func f(x: Foo) -> T {
    return bar
  }
  let bar: T
}
print(type(of: Foo.f))

The compiler produces the following error message, which is arguably less than ideal, as it's quite surprising for any type to not conform to Any:

argument type '((Foo<_>) -> (Foo<_>) -> _).Type' does not conform to expected type 'Any'

Similar problems can be observed in other contexts, but with different messages. For instance, the following expression

let t: Any = type(of: Foo.f)

produces this error, which is better than in the previous example, but still arguably perfectible:

expression type '(_) -> _' is ambiguous without more context

The compiler is able to produce more meaningful messages in more common situations. For instance

let arr = [Foo.f]

produces

generic parameter 'T' could not be inferred