Method to split a `Box<T>` into multiple `Box`es for each of its fields

Similar to #162.

Sometimes we pull apart a Box<T> and then reallocate some of its fields in Boxes again.

We could codegen methods to convert a Box<T> into multiple Boxes for each field, without any reallocations.

e.g.:

pub struct FormalParameter<'a> {
    pub span: Span,
    pub decorators: Vec<'a, Decorator<'a>>,
    pub pattern: BindingPattern<'a>,
    pub accessibility: Option<TSAccessibility>,
    pub readonly: bool,
    pub r#override: bool,
}

trait IntoBoxedFields {
    type Fields;
    fn into_boxed_fields(self) -> Self::Fields;
}

// Codegenned for all AST structs

pub struct FormalParameterBoxedFields<'a> {
    pub span: Box<'a, Span>,
    pub decorators: Box<'a, Vec<'a, Decorator<'a>>>,
    pub pattern: Box<'a, BindingPattern<'a>>,
    pub accessibility: Box<'a, Option<TSAccessibility>>,
    pub readonly: Box<'a, bool>,
    pub r#override: Box<'a, bool>,
}

impl<'a> IntoBoxedFields for Box<'a, FormalParameter<'a>> {
    type Fields = FormalParameterBoxedFields;

    fn into_boxed_fields(self) -> Self::Fields {
        let ptr = Box::into_non_null(self).as_ptr();
        unsafe {
            FormalParameterBoxedFields {
                span: Box::from_ptr(addr_of_mut!((*ptr).span)),
                decorators: Box::from_ptr(addr_of_mut!((*ptr).decorators)),
                pattern: Box::from_ptr(addr_of_mut!((*ptr).pattern)),
                accessibility: Box::from_ptr(addr_of_mut!((*ptr).accessibility)),
                readonly: Box::from_ptr(addr_of_mut!((*ptr).readonly)),
                r#override: Box::from_ptr(addr_of_mut!((*ptr).r#override)),
            }
        }
    }
}

Most of the fields are not useful (why would you want a Box<bool>?). But extracting a Box<'a, BindingPattern<'a>> from Box<'a, FormalParameter<'a>> can be useful.

// Extract 1 field
fn foo(param: Box<'a, FormalParameter<'a>>) -> Box<'a, BindingPattern<'a>> {
    param.into_boxed_fields().pattern
}

// Extract multiple fields
fn bar(param: Box<'a, FormalParameter<'a>>) -> (
    Box<'a, BindingPattern<'a>>,
    Box<'a, Option<TSAccessibility>>,
) {
    let FormalParameterBoxedFields { pattern, accessibility, .. } = param.into_boxed_fields();
    (pattern, accessibility)
}

Compiler will elide the code for any fields you don't use. It avoids using unbox which pulls the whole struct onto the stack, and you don't have to reallocate the data for fields back into the arena again later.

Could also provide more flexibility with a macro:

let (pattern, readonly) = extract_fields!(param, (@box pattern, readonly));
// pattern: Box<'a, BindingPattern<'a>>
// readonly: bool

Start by reading issue #162 and reviewing the proposed IntoBoxedFields trait and extract_fields! macro. Inspect how AST structs are code-generated and how Box::into_non_null and Box::from_ptr are supported. Done requires an agreed design for generated boxed-field extraction, including which fields and API should be supported.