vibe: negative reasoning and solver cycles

[lcnr]

the trait solver sometimes uses negative reasoning, e.g. in discard_impls_shadowed_by_env. Whether we're currently employing negative reason is not tracked by the nested goals.

I am worried that we need to track this as right now a cycle where T: Trait only holds if T: Trait does not hold gets treated incorrectly.

[lcnr]

cc rust-lang/rust#143054

I've also added support for PathKind::ForcedAmbiguity which always forced the initial provisional result to be ambiguous. A am using this for cycles involving negative reasons, which is currently only used by the fuzzer in https://github.com/lcnr/search_graph_fuzz. Consider the following setup: A goal A which only holds if B does not hold, and B which only holds if A does not hold.

* A only holds if B does not hold, results in X
  
  * B only holds if A does not hold, results in !X
    
    * A cycle, provisional result X

* B only holds if A does not hold, results in X
  
  * A only holds if B does not hold, results in !X
    
    * B cycle, provisional result X

With negative reasoning, the result of cycle participants depends on their position in the cycle. This means using cache entries while other entries are on the stack/have been popped is wrong. It's also generally just kinda iffy. By always forcing the initial provisional result of such cycles to be ambiguity, we can avoid this, as "not maybe" is just "maybe" again.

Rust kind of has negative reasoning due to incompleteness, consider the following setup:

* `T::Foo eq u32`
  
  * normalize `T::Foo`
    
    * via impl -> `u32`
    * via param_env -> `T`
      
      * nested goals...

T::Foo eq u32 holds exactly if the nested goals of the param_env candidate do not hold, as preferring that candidate over the impl causes the alias-relate to fail. This means the current provisional cache may cause us to ignore param_env preference in rare cases. This is not unsound and I don't care about it, as we already have this behavior when rerunning on changed fixpoint results:

* `T: Trait`
  
  * via impl ok
  * via env
    
    * `T: Trait` non-productive cycle

* result OK, rerun changed provisional result

* `T: Trait`
  
  * via impl ok
  * via env
    
    * `T: Trait` using the provisional result, can be thought of as recursively expanding the proof tree
      
      * via impl ok
      * via env <don't care>

* prefer the env candidate, reached fixpoint

One could imaging changing ParamEnv candidates or the impl shadowing check to use PathKind::ForcedAmbiguity to make the search graph less observable instead of only using it for fuzzing. However, incomplete candidate preference isn't really negative reasoning and doing this is a breaking change rust-lang/trait-system-refactor-initiative#114