Put the data dictionary behind an interface, and delete the 10,380 lines nobody read.

[xbmlz]

The dictionary was three exported maps: DicomDictionaryGo,
RepeatersDictionaryGo and PrivateDictionaries. Read-only by convention,
mutable by type, with no synchronisation of any kind — any caller could have
corrupted the dictionary for the whole process, and there was no way to
substitute a different one.

The interface

Standard() now returns a Dictionary, whose single
Lookup(tag Tag, creator string) (DictEntry, bool) answers for both halves of
the dictionary: creator names the Private Creator of a private tag and is
ignored for a standard one.

entry, ok := godicom.Standard().Lookup(tag.PatientName, "")
// entry.VR "PN", entry.VM "1", entry.Name "Patient's Name",
// entry.Keyword "PatientName", entry.Retired false

It resolves an exact entry ahead of a repeating-group pattern, which is not
arbitrary — (7FE0,0010) is Pixel Data exactly and retired Variable Pixel
Data through the 7Fxx,0010 mask, and every image ever written means the
former. It never resolves a private tag against the standard tables, because
the same tag means different things to different vendors.

It is also the first public way to read a standard entry's VM, name or retired
flag. LookupVR gave the VR and laundered a missing entry into UN, and the
PrivateDictionary* functions covered only private tags. So this is a
capability gain, not only groundwork.

The package's own four resolvers go through it, so it is the path godicom itself
takes rather than a wrapper around one. That costs nothing:
go build -gcflags='-m' reports inlining call to Standard,
devirtualizing .Lookup to standardDictionary and standardDictionary{} does not escape at all four call sites.

dictionaryHasTag deliberately stays a direct probe of the exact table. The
endianness heuristic needs "this exact tag is a known element", not "something
in the dictionary covers this tag" — the 88 masks cover 108,688 tags between
them against 5,189 exact entries. No read test in the suite distinguishes the
two, so TestDictionaryHasTagIgnoresRepeaters is what holds that line.

Compound VRs

DictEntry.VRs() splits the forms PS3.6 writes as prose. Thirty-seven entries
permit two — OB or OW is PixelData — and (0028,1200) Gray Lookup Table Data
permits three, US or SS or OW.

vrDisagreesWithDictionary compared the whole string against one VR, so it
disagreed with every correctly encoded PixelData element in the world. It uses
VRs() now.

Removed

• dictionaryIsRetired, which consulted only the exact table and so answered
  "not retired" for all 72 retired repeating-group entries. It had no caller
  outside its own test, so nothing ever noticed. Retired is read off the entry
  now.
• the generated tagToKeyword and tagToName maps, 10,380 lines and two
  5,000-entry maps built at init, both a second copy of data dicomDictionary
  already held one map access away. tagToName had no reader at all —
  staticcheck skips generated files, which is why -checks=all never minded.
  keywordToTag stays, because that direction is the one that needs an index.

Two generator bugs fixed on the way

• generate_dict.py wrote to dicom_dict_generated.go, a name nothing in the
  tree has: the checked-in file is dictionary_generated.go. Running the
  generator therefore produced a second file redeclaring DictEntry and every
  map in it, so the package stopped compiling instead of the dictionary being
  updated.
• neither generator gofmt'd its output, while the checked-in files are
  formatted, so regenerating buried the data change under a 5,182-line
  whitespace diff. Both now run gofmt -w, and re-running both against the
  current pydicom submodule is a no-op — 5,189 standard entries, 88 repeaters,
  449 private creators, 10,545 private entries, byte-identical.

Breaking

At 0.x: the three maps and PrivateDictEntry are unexported. Nothing in the
godicom-dev organisation referenced them (checked gonetdicom, golibjpeg,
goopenjpeg and the docs site). DictEntry stays exported — it is what Lookup
returns. AddPrivateDictEntry remains the way to register a private entry at
runtime, and Lookup finds those too.

Verification

• go build ./..., go vet ./..., go test -count=1 -p 4 ./... — green
• staticcheck -checks=all (CI's exact invocation) — clean
• gofmt over all 130 non-generated files — clean
• GOARCH=386 CGO_ENABLED=0 go test ./... — green
• cross-vet over all eight CI targets plus GOARM=5 — clean
• all five behavioural changes proven load-bearing by perturbation. One
  perturbation falsified a comment I had written about dictionaryHasTag; the
  comment now states the measured magnitudes instead of the claim I could not
  support.
• three new Examples (ExampleStandard, ExampleDictEntry_VRs,
  ExampleAddPrivateDictEntry) keep the new README section compile-checked, per
  f17c828.

Groundwork for #71. Deliberately not in this PR: ReadOptions.Dictionary /
WriteOptions.Dictionary threading and dictionary.New(...) composition, which
need their own API round.

🤖 Generated with Claude Code