Fix marker trait winnowing depending on impl order

The `TypeOutlives` handler in `evaluate_predicate_recursively`
checks whether a type in a `T: 'a` predicate has free regions,
bound regions, or inference variables -- and if so, returns
`EvaluatedToOkModuloRegions` rather than `EvaluatedToOk`.  The
comment says "no free lifetimes or generic parameters", but the
code checked `has_non_region_infer` twice instead of checking
`has_non_region_param()`.

This meant that `TypeOutlives(T, 'static)` where `T` is a type
parameter returned `EvaluatedToOk` -- claiming the result holds
unconditionally -- when the correct answer is
`EvaluatedToOkModuloRegions`.

The distinction matters during marker trait
winnowing in `prefer_lhs_over_victim`, which uses
`must_apply_considering_regions()` (true only for `EvaluatedToOk`)
to decide whether one overlapping impl beats another.  With the
bug, a `T: 'static`-bounded impl appeared equally as strong as an
unrestricted impl, making the winner depend on source order.  This
caused spurious E0310 errors when the more-constrained impl happened
to appear after the less-constrained one.

Fixes Rust issue 109481.

This same symptom was originally filed as issue 84917 and fixed in PR
88139.  Then PR 102472 rewrote the `TypeOutlives` handler, introducing
the duplicate `has_non_region_infer()` and losing the param check,
regressing this.  Shortly after, issue 109481 was filed.  It noted the
connection to PR 102472 -- that it was only relevant after it -- but
the duplicate condition was not noticed.

Author: traviscross

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -750,7 +750,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     if pred.0.has_free_regions()
                         || pred.0.has_bound_regions()
                         || pred.0.has_non_region_infer()
-                        || pred.0.has_non_region_infer()
+                        || pred.0.has_non_region_param()
                     {
                         Ok(EvaluatedToOkModuloRegions)
                     } else {

tests/ui/marker_trait_attr/overlapping-impl-1-modulo-regions.rs

@@ -1,12 +1,13 @@
-//@ known-bug: #109481
+//@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 //
-// While the `T: Copy` is always applicable when checking
-// that the impl `impl<T: Copy> F for T {}` is well formed,
-// the old trait solver can only approximate this by checking
-// that there are no inference variables in the obligation and
-// no region constraints in the evaluation result.
+// Regression test for #109481 and #84917.
 //
-// Because of this we end up with ambiguity here.
+// Overlapping marker trait impls where one has a `T: 'static` bound
+// should be accepted.  A bug previously made marker trait winnowing
+// order-dependent, producing a spurious E0310 here.
 #![feature(marker_trait_attr)]
 
 #[marker]