Meta types to replace derive logic

[joshlf]

Imagine the following type:

// Has the same layout as a `#[repr(C)]` struct with `L` fields
struct ReprC<L: TyList> { ... }

Imagine further that this type has hand-rolled impls of all of the zerocopy traits.

We could then simplify our derives to handle types like:

#[derive(KnownLayout)]
#[repr(C)]
struct Foo<A, B: ?Sized> {
    a: A,
    b: B,
}

By emitting:

unsafe impl<A, B: ?Sized> KnownLayout for Foo<A, B>
where
    ReprC<(A, B)>: KnownLayout
{
    type PointerMetadata = <ReprC<(A, B)> as KnownLayout>::PointerMetadata;
    const LAYOUT: DstLayout = <ReprC<(A, B)> as KnownLayout>::LAYOUT;

    fn raw_from_ptr_len(bytes: NonNull<u8>, meta: Self::PointerMetadata) -> NonNull<Self> {
        let ptr = <ReprC<(A, B)> as KnownLayout>::raw_from_ptr_len(bytes, meta).as_ptr();
        let ptr = ptr as *mut Self;
        unsafe { NonNull::new_unchecked(ptr) }
    }

    fn pointer_to_metadata(ptr: *mut Self) -> Self::PointerMetadata {
        <ReprC<(A, B)> as KnownLayout>::pointer_to_metadata(ptr as *mut ReprC<(A, B)>)
    }
}

We could presumably do something similar for other traits, and we could presumably support other #[repr(...)] attributes and other kinds (enums and unions). Ideally this would let us drastically simplify the internals of our derives.