Issue Description:

In the following code, there is a typealias defined inside of a protocol that happens to shadow a concrete type of the same name that exists outside of the protocol. When defining a custom type based on that protocol, the compiler appears to chose either the outer scope name or the inner scope one depending on how it is used.

protocol SomeProtocol {
    typealias SomeType = Int
}


struct SomeType {
    static var wrong: SomeType { fatalError() }
}


struct SomeImplementationA: SomeProtocol {
    var property = SomeType()
}


struct SomeImplementationB: SomeProtocol {
    var property: SomeType
}


func someTest() {
    let a = SomeImplementationA(property: 10)  // property is of type SomeProtocol.SomeType (the protocol's Int typealias)

    let b = SomeImplementationB(property: .wrong)  // property is of type SomeType (the outer struct)
}

I would expect the typealias defined by the protocol to always "win" no matter where the type is used as long as I'm inside that context. (I'm not sure what the correct words are here, but hopefully this makes sense.)