subtype obligations drop nested WF obligations required due to bivariant args

[lcnr]

enum State<S, T>
where
    S: Iterator<Item = T>,
{
    Active { upstream: S },
    WindDown,
    Complete,
}

impl<S, T> State<S, T>
where
    S: Iterator<Item = T>,
{
    fn foo(self) {
        let x = match self {
            State::Active { .. } => None,
            State::WindDown => None,
            State::Complete => Some(State::Complete),
        };
        let _: Option<State<S, T>> = x;
    }
}

results in

error: internal compiler error: unexpected inference variable after writeback: Binder { value: SubtypePredicate { a_is_expected: true, a: State<S/#0, ?46t>, b: State<S/#0, T/#1> }, bound_vars: [] }
  --> src/main.rs:17:32
   |
17 |             State::WindDown => None,
   |                                ^^^^
   |
note: delayed at compiler/rustc_hir_typeck/src/writeback.rs:794:36 - disabled backtrace
  --> src/main.rs:17:32
   |
17 |             State::WindDown => None,
   |                                ^^^^

error: internal compiler error: unexpected inference variable after writeback: Binder { value: SubtypePredicate { a_is_expected: false, a: State<S/#0, T/#1>, b: State<S/#0, ?46t> }, bound_vars: [] }
  --> src/main.rs:16:37
   |
16 |             State::Active { .. } => None,
   |                                     ^^^^
   |
note: delayed at compiler/rustc_hir_typeck/src/writeback.rs:794:36 - disabled backtrace
  --> src/main.rs:16:37
   |
16 |             State::Active { .. } => None,
   |                                     ^^^^

[lcnr]

trait Trait {
    type Assoc; 
}
impl<T> Trait for T {
    type Assoc = T;
}

struct Foo<T: Trait<Assoc = U>, U>(T);

fn main() {
    let x = None.unwrap();
    let y = x;
    let _: Foo<_,  _> = x;
    let _: Foo<u32, u32> = x; 
}

• let y = x results in a Subtype(?x, ?y) obligation
• after let _: Foo<_, _> = x; this obligation relates Foo<?0, ?1> with ?y. This results in nested
  • WellFormed(?y) = WellFormed(Foo<?2, ?3>) and Subtype(?0, ?2) obligations
• after let _: Foo<u32, _> = x; we try to prove the Subtype(Foo<u32, u32>, Foo<?2, ?3>). This constrains ?2 to u32 but does not prove WellFormed(Foo<u32, ?3>) again.
• We never constrain ?3

error[E0282]: type annotations needed for `Foo<u32, _>`
  --> src/main.rs:12:9
   |
12 |     let y = x;
   |         ^
   |
help: consider giving `y` an explicit type, where the type for struct `Foo<u32, _>` is specified
   |
12 |     let y: Foo<_, _> = x;
   |          +++++++++++