Only scan the affected suffix of the provisional cache

`insert_provisional` walks the whole provisional cache on every insert to
lower `reached_depth`. Everything it can affect was inserted while
`from_dfn` was on the stack, so it is a suffix of this insertion-ordered
map and the walk can stop at the first older entry.

The full walk is quadratic in the size of the cache, which only fills up
for types that are mutually recursive. Proving `Send` for a graph of N
such types did about N^2 iterations of this loop: 641M for N=480.

`evaluate_obligation` on that graph, before and after:

    N=60    63ms ->  41ms
    N=120  172ms ->  80ms
    N=240  531ms -> 167ms
    N=480    -    -> 316ms

which is the linear growth the same graph already has when it is acyclic.

Author: Dandandan

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

@@ -3116,10 +3116,13 @@ impl<'tcx> ProvisionalEvaluationCache<'tcx> {
         //          A // depth 0
         //   D (reached depth 1)
         //      C (cache -- reached depth = 2)
-        for (_k, v) in &mut *map {
-            if v.from_dfn >= from_dfn {
-                v.reached_depth = reached_depth.min(v.reached_depth);
+        // Anything this can affect was inserted while `from_dfn` was on the
+        // stack, so it is a suffix of this insertion-ordered map.
+        for (_k, v) in map.iter_mut().rev() {
+            if v.from_dfn < from_dfn {
+                break;
             }
+            v.reached_depth = reached_depth.min(v.reached_depth);
         }
 
         map.insert(fresh_trait_pred, ProvisionalEvaluation { from_dfn, reached_depth, result });