Okay I've been working on the alternative, but it creates a lot more classes for little benefit. I think the current behavior is correct:
1. There isn't a need to "build" a type when the builder is nested, only to finish a type and return the parent to add more. Plus, it would be bad to include methods that returned valid `Type` objects that short-circuit the builder nesting:
```
Type message = Builders.messageType()
                       .required(INT32).named("id")
                       .optional(BINARY).as(UTF8).build("name");
```
2. There isn't a need to return the parent of an independent builder (that returns a Type) because it doesn't have one.
3. Ideally, the method to finish an independent builder and the method to finish a nested builder would be the same.

The straight-forward solution is to have two builder classes: an independent builder that returns the Type and knows nothing of parents, and a nested builder that returns its parent after adding the constructed type. But this leads to twice the number of builder classes, and the return type, P, still can't extend `GroupBuilder` without adding even more.

I think the existing approach here is worth the trade-off to simplify the builders, since this is the only code that changes between the two potential builder classes.