feat: param(key, name[, T]) — closes #32

[sotashimozono]

Closes #32.

work_fn opened with Float64(key.params["system.kbT"]), and both halves of that were a hazard.

param(key, "system.kbT")            # dotted
param(key, "kbT")                   # the leaf, when only one group has it
param(key, "a")                     # AmbiguousPathKeyError, naming ["model", "system"]
param(key, "system.kbt")            # error listing what the key does carry
param(key, "system.a", Float64)     # 2.0
param(key, "system.kbT", Int)       # InexactError, at the boundary

A misspelled name was a bare KeyError naming only the string that was wrong — raised inside the
work function, on a worker, dispatched by run!. The config with the right spelling and the
function with the wrong one are in different files, and nothing compares them until a point is
computed.

The review changed more than it confirmed

Six passes over this branch. The substantive findings, all reproduced before acting on them:

A bare catch was swallowing everything. _resolve_axis_value caught the resolver's two
intended errors and also InterruptException, and any future bug. The consequence is concrete:
build_axis_formats returns an empty Dict, format_path falls back to fixed2, and 0.006 and
0.008 both render as sysg0.01 — one run's directory overwriting another's, which is the failure
format.jl's own header says auto mode exists to prevent.

Fixed by removing the try rather than narrowing it. _lookup_name returns the outcome — key,
groups, or nothing — and _resolve_name decides what to raise. The caller for which absent and
ambiguous are ordinary now asks instead of catching.

param(key, name, T) did not keep its own promise. It said it refuses a conversion that changes
the number; convert only does that for integer targets. Measured:

convert(Float64, 9007199254740993)  ->  9.007199254740992e15   silently one less
convert(Float32, 2.1)               ->  2.1f0                  silently rounded

Now converted and checked, so the promise holds for every T. The test fixture had to be replaced
to show it: 2.5 is exact in Float32, so the first version asserted a refusal on a value that
cannot lose anything and would have passed for the wrong reason.

The version was wrong. 0.5.0 for a purely additive change, while DataVault pins
ParamIO = "0.3, 0.4" — the next layer of the stack could not have resolved it at all. 0.4.8.

Three comments claimed things that were not true. The header said the rule's copies "drifted:
two raise AmbiguousPathKeyError and two raise a bare error". It is one typed, two bare, and one
that raised nothing at all — and erasing that last one hid the larger difference. The catch
comment said this was "the one caller" that swallows; _safe_format_path in diagnose.jl does the
same. A testset title claimed parity with the path builder, which raises a different exception for
the same condition.

Two functions the rewrite touched had no test that reached them. Every existing call to
build_axis_formats passes fully dotted path_keys, which take the exact-match short-circuit — so
the leaf branch and both failure paths were unexercised, and "behaviour is unchanged" was
unverifiable. The 3-arg format_path's leaf branch was likewise unpinned while the 2-arg one was;
it formats without the group prefix on purpose, so a later conversion would move results on
disk. Both are now covered.

The README taught the thing this PR replaces. key.params["N"] # ❌ KeyError was presented as
the shape to avoid — which is exactly what param resolves — and neither it nor the new files were
listed. Same for CLAUDE.md.

Still not converted, and the earlier reason was wrong

format_path (both forms) and _validate_path_keys keep their own copies of the rule. The reason
given in the previous commit — that _resolve_name cannot report which way a name resolved — is
false: resolved == pk reports exactly that, and a reviewer reproduced the conversion byte-for-byte.

The real reason to defer is that converting format_path changes its exception type for an
ambiguous leaf, from ErrorException to AmbiguousPathKeyError. That is a public behaviour change,
and it does not belong in a pull request that adds an accessor.

Verification

Full suite 10/10 units, 919 pass, 0 fail, before and after formatting.

[github-actions]

📚 Docs preview: https://codes.sota-shimozono.com/ParamIO.jl/previews/PR33/

(updates on each push to this PR)

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!