How to best hint at rustc that a recursive data-structure based on Pointee::Metadata is well-formed?

The Rust compiler chokes on the following code:

#![feature(ptr_metadata)]

use core::ptr::Pointee;

struct TypedHandle<E: ?Sized, H> {
    handle: H,
    metadata: <E as Pointee>::Metadata,
}

type NodeHandle<T, H> = TypedHandle<Node<T, H>, H>;

struct Node<T, H> {
    element: T,
    next: NodeHandle<T, H>,
    prev: NodeHandle<T, H>,
}

There seems to be a type inference/type resolution issue, however the notes are all over the place with weirdly seemingly unrelated suggestions:

error[E0284]: type annotations needed
  --> src/lib.rs:14:11
   |
14 |     next: NodeHandle<T, H>,
   |           ^^^^^^^^^^^^^^^^ cannot infer type
   |
   = note: cannot satisfy `<Node<T, H> as Pointee>::Metadata == _`
note: required because it appears within the type `TypedHandle<Node<T, H>, H>`
  --> src/lib.rs:5:8
   |
5  | struct TypedHandle<E: ?Sized, H> {
   |        ^^^^^^^^^^^
   = note: only the last field of a struct may have a dynamically sized type
   = help: change the field's type to have a statically known size
help: borrowed types always have a statically known size
   |
14 |     next: &NodeHandle<T, H>,
   |           +
help: the `Box` type always has a statically known size and allocates its contents in the heap
   |
14 |     next: Box<NodeHandle<T, H>>,
   |           ++++                +

Various changes to the code "solve" the error (but break functionality):

• Using NonNull<E> instead of <E as Pointee>::Metadata. This suggests that the recursive nature of the type is not the sole issue.
• Removing the ?Sized bound on E in TypedHandle.
• Removing one of next or prev. This suggests that the note about next not being able to be both unsized and non-last field is actually "serious", despite the fact that TypedHandle is always sized.

Various changes to the code that do not help:

• Switching NodeHandle from type alias to tuple struct. It doesn't help with the error message either.

The only solution I found so far is adding where NodeHandle<T, H>: Sized bound to Node, which is quite unwieldy as this bound has to be replicated everywhere afterwards.

• Is this a known limitation of the compiler?
• Is there a better way to solve the problem?

Note: the problem appeared in a custom implementation of LinkedList as I explore a new allocation API, I worked around it by copy/pasting TypedHandle into SizedHandle and removing the ?Sized bound on E, which leaves an ugly taste in my mouth, but is easier to fix back than copy/pasted bounds all over the place.

This is a nightly regression, which @lukas-code identified in this github comment on the I issue raised.

In the very same comment, he also suggests a much more lightweight work-around: adding a _tail: () field to make the compiler realize a type is sized.

In particular, the TypedHandle definition can be changed to:

struct TypedHandle<E: ?Sized, H> {
    handle: H,
    metadata: <E as Pointee>::Metadata,
    _self_is_always_sized: (),
}

So that the work-around is as scoped as possible.