consider a different handling of allOf constructs

[ahl]

Currently an allOf results in a struct with the component schemas generated and flattened. This is often fine; it has the nice attribute that subordinate types are present in the final type. It can also be imprecise or awkward to use the generated type as the relevant components may be scattered around.

Another way to handle these schemas would be to first "consolidate" all members of the allOf construct. This would effectively mean taking the intersection of all validation criteria (paying attention to the value of additionalProperties). In order to preserve the relationship with the original component types, we could impl From<AllOfType> for ComponentType { ... } and allow users to convert between them (or clone().into::<ComponentType>() to do so non-destructively).

This could be an interesting use case to consider: https://github.com/Marwes/debugserver-types/blob/master/src/schema.json

In particular, we'd want to see a type like:

struct ContinuedEvent {
    event: Continued, // enum Continued { Continued }
    body: ContinuedEventBody,
    type_: EventType, // enum EventType { Event }
    seq: i64
}

impl From<ContinuedEvent> for Event {
    fn from(value: ConteinuedEvent) -> Event {
        Event {
            event: value.event.to_string(),
            body: value.body.to_value(),
            type_: value.type_,
            seq: value.seq,
        }
    }
}

This would likely focus on TypeSpace::maybe_all_of_subclass

[ahl]

Note that a big chunk of this is now done. What's missing is the impl From to get to the original type.

[ahl]

Closed in favor of #726