feat: add modelsdk — auto-generated, type-safe model SDK with BSON roundtrip

Add a new `modelsdk/` package that provides a fundamentally better
architecture for reading and writing Mendix MPR files compared to the
existing hand-written `sdk/` layer.

This is an additive, non-breaking change — no existing code is modified.
The new package coexists with `sdk/` to enable gradual migration.

Key improvements over current sdk/:

- 1,500+ auto-generated types across 53 Mendix domains (vs ~480 hand-written)
- Type registry with automatic init() registration (vs manual dispatch)
- Dirty tracking via bitmap + container chain propagation
- BSON roundtrip preservation — unknown fields survive read/write cycles
- Lazy decode via InitFromRaw() — zero cost for unaccessed fields
- Three-branch encoder: self-dirty / child-dirty / clean pass-through
- Property abstraction: Primitive[T], Part[T], PartList[T], Enum[T], ByNameRef[T]
- Per-property version metadata (introduced/deleted/public)
- Reference registry for cross-domain relationship tracking

Packages added:
- modelsdk/codec — BSON encoder/decoder with type registry
- modelsdk/element — Element interface with dirty tracking
- modelsdk/property — Generic property types with lazy init
- modelsdk/gen/ — 53 auto-generated domain packages
- modelsdk/mpr — MPR v1/v2 reader/writer
- modelsdk/widgets — Widget template handling
- modelsdk/meta — System module metadata
- modelsdk/version — Version compatibility info
- cmd/modelsdk-codegen — Code generator from TS SDK reflection data
- internal/codegen/dtsparser — TypeScript SDK parser
- internal/codegen/emitter — Go code generation templates

Author: claude

cmd/modelsdk-codegen/audit.go

@@ -0,0 +1,104 @@
+package dtsparser
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestParseAllDomains(t *testing.T) {
+	genDir := "../../../reference/mendixmodelsdk/src/gen"
+
+	// Collect all enums across modules
+	allEnums := collectCrossModuleEnums(genDir)
+	t.Logf("Cross-module enums collected: %d", len(allEnums))
+
+	entries, err := os.ReadDir(genDir)
+	if err != nil {
+		t.Fatalf("cannot read gen dir: %v", err)
+	}
+
+	totalClasses := 0
+	totalEnums := 0
+	totalProps := 0
+	totalStructTypeNames := 0
+	kindCounts := map[PropertyKind]int{}
+	domainSummary := []string{}
+
+	for _, entry := range entries {
+		if !strings.HasSuffix(entry.Name(), ".d.ts") {
+			continue
+		}
+		domain := strings.TrimSuffix(entry.Name(), ".d.ts")
+		if domain == "base-model" || domain == "all-model-classes" {
+			continue // meta files, not domain files
+		}
+
+		dtsData, err := os.ReadFile(filepath.Join(genDir, entry.Name()))
+		if err != nil {
+			t.Errorf("cannot read %s: %v", entry.Name(), err)
+			continue
+		}
+
+		classes, enums := parseDtsFileWithEnums(string(dtsData), allEnums)
+
+		// Also parse .js for structureTypeNames
+		jsFile := strings.TrimSuffix(entry.Name(), ".d.ts") + ".js"
+		jsData, _ := os.ReadFile(filepath.Join(genDir, jsFile))
+		stns := parseStructureTypeNames(string(jsData))
+
+		domainClasses := len(classes)
+		domainEnums := len(enums)
+		domainProps := 0
+		for _, c := range classes {
+			domainProps += len(c.Properties)
+			for _, p := range c.Properties {
+				kindCounts[p.Kind]++
+			}
+		}
+
+		totalClasses += domainClasses
+		totalEnums += domainEnums
+		totalProps += domainProps
+		totalStructTypeNames += len(stns)
+
+		domainSummary = append(domainSummary,
+			fmt.Sprintf("%-30s classes=%3d enums=%2d props=%4d $Types=%3d",
+				domain, domainClasses, domainEnums, domainProps, len(stns)))
+	}
+
+	t.Log("=== Per-Domain Summary ===")
+	for _, s := range domainSummary {
+		t.Log(s)
+	}
+
+	t.Log("=== Totals ===")
+	t.Logf("Domains:             %d", len(domainSummary))
+	t.Logf("Total classes:       %d", totalClasses)
+	t.Logf("Total enums:         %d", totalEnums)
+	t.Logf("Total properties:    %d", totalProps)
+	t.Logf("Total $Type names:   %d", totalStructTypeNames)
+
+	t.Log("=== Property Kind Distribution ===")
+	for k, v := range kindCounts {
+		t.Logf("  %-10s: %4d (%.1f%%)", k, v, float64(v)/float64(totalProps)*100)
+	}
+
+	// Classification rate
+	unknownPct := float64(kindCounts[KindUnknown]) / float64(totalProps) * 100
+	classRate := 100 - unknownPct
+	t.Logf("Classification rate: %.1f%%", classRate)
+
+	// Assertions
+	if len(domainSummary) < 40 {
+		t.Errorf("expected at least 40 domains, got %d", len(domainSummary))
+	}
+	if totalClasses < 200 {
+		t.Errorf("expected at least 200 classes, got %d", totalClasses)
+	}
+	if classRate < 80 {
+		t.Errorf("classification rate %.1f%% too low, expected >= 80%%", classRate)
+	}
+}