This is in principle not hard to support, but in practice it requires a bit of thought.

For instance, do we want to prevent the foot-gun of mixing in stuff not meant to go into the nested table? I think allowing that is too large a footgun for me to be comfortable with it (both in terms of performance and in terms of leaking unintended data).

I am thinking that maybe we can do something like this?

struct NestedBuilder<'a> { builder: &'a mut Builder }

impl Builder {
    fn nested_builder<'a>(&'a mut self) -> NestedBuilder<'a> { ... }
}

impl<'a> NestedBuilder<'a> {
    fn nested_builder<'b>(&'a mut self) -> NestedBuilder<'b> { ... }
    fn finish<T>(self, root: Offset<T>) -> Offset<NestedBuffer<T>> { ... }
}

And then re-structuring the builder trait so what they work with either a Builder or a NestedBuilder.

@TheButlah Do you think that API would work for your use-case?

That would probably work, although I should not be relied on as a person to give opinions on y'alls apis.