TS: Move createResource to a shared factory function on the base type module

[ryukzak]

Currently each profile class has a static createResource() method that builds a plain resource with buildResource<T>():

// In Bundle_ExampleTypedBundle.ts (profile module)
static createResource (args: ExampleTypedBundleProfileRaw) : Bundle {
    const resource = buildResource<Bundle>( {
        resourceType: "Bundle",
        type: args.type,
        meta: { profile: [ExampleTypedBundleProfile.canonicalUrl] },
    })
    return resource;
}

This duplicates the base resource construction across every profile on the same type (e.g. multiple Observation profiles each have their own buildResource<Observation>(...)).

Proposal

Generate a shared createResource factory function in the base type module (e.g. Bundle.ts, Observation.ts) and have profile classes call it:

// In Bundle.ts (base type module)
export const createBundle = (args: { type: Bundle["type"], ... }): Bundle =>
    buildResource<Bundle>({ resourceType: "Bundle", ...args });

// In Bundle_ExampleTypedBundle.ts (profile module)
import { createBundle } from "../../hl7-fhir-r4-core/Bundle";

static createResource (args: ExampleTypedBundleProfileRaw) : Bundle {
    return createBundle({ type: args.type, meta: { profile: [canonicalUrl] } });
}

This keeps resource construction in one place per base type, shared across all profiles.

[ryukzak]

Resolved in #126 with a different approach than originally proposed:

Instead of generating shared create<ResourceType> factory functions in base type modules, we:

1. Removed buildResource<T>() entirely — profile createResource now uses plain object literals (const resource: T = { ... }) instead of buildResource<T>({...})
2. Fixed Reference type safety — base types with family type references (e.g. Resource) now generate Reference<string /* Resource */> instead of Reference<"Resource">, making narrower profile references like Reference<"Patient"> directly assignable without casts
3. Fixed choice field reference resolution — tryPromoteChoice now resolves reference targets properly via fieldTsType instead of tsTypeFromIdentifier

The shared factory approach was unnecessary since the real issue was type compatibility between profiles and base types, not code duplication.