Implement coherence checks for negative trait impls

[yaahc]

Motivation

This change is needed as part of rust-lang/project-error-handling#3. We need to be able to define From<&str> for Box<dyn Error> in order to maintain our existing stable APIs but moving the Error trait upstream of this implementation introduces a future incompatibility error. rustc can't tell that future incompatibility is meaningless between core and std nor that we never intend to implement Error for &str. Adjusting the coherence rules to consider negative trait impls lets us add impl !Error for &str to core to make an API guarantee that we will never implement Error for &str and let's us implement the previously mentioned From impl without getting errors of it potentially overlapping with From<E> for Box<dyn Error> where E: Error.

Alternatives Considered

• Design and Implement a feature for wider coherence boundaries that allows multiple crates to be treated like one crate for coherence purposes then use this feature on core and alloc
  • This feels like a substantial amount of work and I don't even have confidence I could come up with something and get it through the RFC process in a reasonable amount of time.
• Add a special case exception for the future incompatibility error which ignores it when the crates involved are part of the rust distribution and thus versioned in lockstep.
  • Sounds icky, not confident people would even want this in the compiler, feels like a low budget version of the wider coherence feature

Current Status

these notes are as much for myself as for anyone else, and are just recording the state as of the last time I paused for the day on this PR

Recent convo: https://rust-lang.zulipchat.com/#narrow/stream/144729-wg-traits/topic/negative.20impls.20in.20coherence

I met up with niko to talk about the approach a bit and we sketched out how we'd implement this in rustc:

• add a new kind of predicate that is T: !Trait
  • or extend the existing predicate with a polarity
• teach the trait checker to prove T: !Trait if there are negative impls
  • update overlap_with_probe to check for negation before checking for overlap

.find(|o| {
    if let Some(o_neg) = negate_obligation(o) {
        // given o = `T: Trait` this produces `T: !Trait`
        if selcx.predicate_must_hold(o_neg) {
            // we can prove `T: !Trait` is true based on the impls we see
            return true;
        }
    }
    !selcx.predicate_may_hold_fatal(o)
})

Still figuring out what the second step means for now.

[rust-highfive]

r? @jackh726

(rust-highfive has picked a reviewer for you, use r? to override)

[spastorino]

Closing this one given that #90104 is already merged.