are Bounds in a trait's associated item a subset of WhereBounds?

The docs say this about the difference between Bounds and WhereBounds (https://doc.rust-lang.org/reference/items/associated-items.html#relationship-between-bounds-and-wherebounds)

trait Example {
    type Output<T>: Ord where T: Debug;
}

> Given a reference to the associated type like <X as Example>::Output<Y>,
> the associated type itself must be Ord, and the
> type Y must be Debug.

This variant also compiles

trait Example {
    type Output<T>
    where
        Self::Output<T>: Ord,
        T: Debug;
}

as does this(!)

trait Example {
    type Output<T>: Ord
    where
        Self::Output<T>: Ord,
        T: Debug;
}

do these have different semantics? Is Bounds just a syntactic convenience for the common case of applying trait bounds to the associated type being defined, while WhereBounds is strictly more general?

This function will prove they're not equal:

fn assert_ord<T: Ord>() {}

fn foo<T: Example>() {
    assert_ord::<T::Output<i32>>();
}

It compiles with:

trait Example {
    type Output<T>: Ord;
}

But fails with:

trait Example {
    type Output<T>
    where
        Self::Output<T>: Ord;
}

With the error:

error[E0277]: the trait bound `<T as Example>::Output<i32>: Ord` is not satisfied
  --> src/lib.rs:10:18
   |
10 |     assert_ord::<T::Output<i32>>();
   |                  ^^^^^^^^^^^^^^ the trait `Ord` is not implemented for `<T as Example>::Output<i32>`
   |
note: required by a bound in `assert_ord`
  --> src/lib.rs:7:18
   |
7  | fn assert_ord<T: Ord>() {}
   |                  ^^^ required by this bound in `assert_ord`
help: consider further restricting the associated type
   |
9  | fn foo<T: Example>() where <T as Example>::Output<i32>: Ord {
   |                      ++++++++++++++++++++++++++++++++++++++

But there's more: just implementing the trait will fail for the second variant will fail:

trait Example {
    type Output<T>
    where
        Self::Output<T>: Ord;
}

impl Example for () {
    type Output<T> = String;
}

error[E0275]: overflow evaluating the requirement `<() as Example>::Output<T> == _`
 --> src/lib.rs:8:5
  |
8 |     type Output<T> = String;
  |     ^^^^^^^^^^^^^^

Whereas it compiles fine for the first variant.

The same behavior can be seen with non-generic associated types.

There is very little documentation on this subject, but the GAT RFC explains this:

> ## Evaluating bounds and where clauses
>
> ### Bounds on associated type constructors
>
> Bounds on associated type constructors are treated as higher rank
> bounds on the trait itself. This makes their behavior consistent with
> the behavior of bounds on regular associated types. For example:
>
> rust
> trait Foo {
> type Assoc<'a>: Trait<'a>;
> }
>
>
> Is equivalent to:
>
> rust
> trait Foo where for<'a> Self::Assoc<'a>: Trait<'a> {
> type Assoc<'a>;
> }
>
>
> ### where clauses on associated types
>
> In contrast, where clauses on associated types introduce constraints
> which must be proven each time the associated type is used. For
> example:
>
> rust
> trait Foo {
> type Assoc where Self: Sized;
> }
>
>
> Each invocation of <T as Foo>::Assoc will need to prove T: Sized,
> as opposed to the impl needing to prove the bound as in other cases.

I'm not sure what is the reason for the "overflow evaluating the requirement" error, though.