Issue Description:

Consider the following code:

protocol Container {
    associatedtype Item: Equatable
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}
extension Array: Container where Element: Equatable { }
func f<T: Equatable>(_ items: [T]) -> some Container {
    return items
}
let x = f([0])
let y = f([1])
let z = x[0] == y[0]

I don't think this should compile, but it does! `x` and `y` are different containers, how/why is the compiler able to tell that the different calls to `f` are returning opaque types with the same associated type? I think the only information that should be accessible is that the element is Equatable. This means that `x[0] == x[1]` would compile but `x[0] == y[0]` would not. It seems like information about the concrete type is "leaking through" and being used to check the call to `==`.