Inherent methods are prioritized over trait methods:

trait Trait {
    fn method(&self) -> i32;
}

struct S;

impl S {
    fn method(&self) -> i32 { // <-- inherent method
        0
    }
}

impl Trait for S {
    fn method(&self) -> i32 { // <-- trait method
        0
    }
}

fn f(S s) {
    s.method(); // <-- calls inherent method
}

Previously, this prioritization was applied after the recursive type inference loop, because it involved a negative call to the method resolution (and hence type inference) relation.

However, as the added test case shows, this may lead to an explosion in inferred types, when the type signatures of the inherent/trait methods differ. This PR hence moves the restriction into the type inference loop, but in order to avoid non-monotonic recursion, we formulate the restriction as a monotonic property: A trait method only applies when all potential inherent targets have a receiver type that it not an instance of the impl type (the non-monotonic version is: there is no receiver type that is an instance of the impl type).