TS: make Bundle<T> generic by propagating nested type params

[ryukzak]

Closes #145.

Summary

• Parent interfaces now become generic when any of their fields reference a generic nested type. The type parameter is carried through at the reference site.
• Applies to Bundle (via BundleEntry<T>) and will also kick in for any other resource whose nested types happen to be generic.
• Default type parameter keeps existing call sites working — zero breakage.

Generated output (before / after)

Motivation: callers couldn't narrow Bundle.entry[i].resource without hand-rolled intersection types.

Before:

export interface Bundle extends Resource {
    resourceType: "Bundle";
    entry?: BundleEntry[];
    // ...
}

After:

export interface Bundle<T extends Resource = Resource> extends Resource {
    resourceType: "Bundle";
    entry?: BundleEntry<T>[];
    // ...
}

Usage

const bundle: Bundle<Patient | Observation> = {
    resourceType: "Bundle",
    type: "transaction",
    entry: [
        { fullUrl: `urn:uuid:${patient.id}`, resource: patient },
        { fullUrl: `urn:uuid:${obs.id}`, resource: obs },
    ],
};

// TS 5.5+ infers the type predicate from the discriminated union — no explicit `r is Observation` needed
const observations = (bundle.entry ?? [])
    .map(e => e.resource)
    .filter(r => r?.resourceType === "Observation"); // Observation[]

Implementation

• Extracted the generic-params computation in generateType() into a reusable helper computeGenericInfo that works for both nested and top-level schemas.
• generateNestedTypes now returns a per-nested-type Record<string, GenericInfo> which is threaded back into the parent's generateType call.
• When a parent field's type points to a generic nested type, the parent adopts the nested's generic params (same names/constraints) and appends the args at the reference site (e.g. BundleEntry<T>[]).
• Scope is limited to the natural pass-through case — no new family-type detection, no renaming heuristics.

Tests

• Added unit assertion generates Bundle with generic entry type (nested generic propagation) in typescript.test.ts — directly covers the nested propagation path.
• Updated resource.test.ts demo to drop the explicit (r): r is Observation predicate; TS 5.5+ infers it automatically from the discriminated union, which is the whole point of the feature.