Don't return definite guidance if we find one solution and then flounder

If we find one solution and then flounder, this previously resulted in a
`Guidance::Definite` result. I think the reason is that `any_future_answer` has
no answers to check and hence returns true.

chalk-solve/src/solve/slg/aggregate.rs

@@ -69,6 +69,10 @@ impl<I: Interner> context::AggregateOps<SlgContext<I>> for SlgContextOps<'_, I>
                 break Guidance::Unknown;
             }
 
+            if let AnswerResult::Floundered = answers.peek_answer(|| should_continue()) {
+                break Guidance::Suggested(subst);
+            }
+
             if !answers.any_future_answer(|ref mut new_subst| new_subst.may_invalidate(&subst)) {
                 break Guidance::Definite(subst);
             }

tests/test/misc.rs

@@ -96,6 +96,30 @@ fn flounder() {
     }
 }
 
+/// Don't return definite guidance if we flounder after finding one solution.
+#[test]
+fn flounder_ambiguous() {
+    test! {
+        program {
+            trait IntoIterator { }
+            #[non_enumerable]
+            trait OtherTrait { }
+
+            struct Ref<T> { }
+            struct A { }
+
+            impl IntoIterator for Ref<A> { }
+            impl<T> IntoIterator for Ref<T> where T: OtherTrait { }
+        }
+
+        goal {
+            exists<T> { Ref<T>: IntoIterator }
+        } yields {
+            "Ambiguous; suggested substitution [?0 := A]"
+        }
+    }
+}
+
 // Test that, when solving `?T: Sized`, we only wind up pulling a few
 // answers before we stop.
 // Also tests that we search breadth-first.