fix(compilers/openapi): resolve a percent-encoded $ref fragment

[OmarAlJarrah]

Closes #40.

Summary

A $ref is a URI, and RFC 3986 allows its fragment to be percent-encoded — a component named
Foo-Bar may legitimately be addressed as #/components/schemas/Foo%2DBar. Reference resolution
split the ref by hand and compared the raw fragment text against the declared component names, so
every spec-correct escape missed.

Scope.InternalPointer now reads the ref with the resolver’s own accessors (references.Reference,
already a dependency of this package) rather than re-deriving the split. Agreeing with the library
that actually performs the resolution is the property that matters here: when the two disagree, the
compiler either calls a resolved reference unresolved, or interns a node at a coordinate no source
position spells. nodeview.InternalPointer was already written against those same two methods for
the cycle scan — this brings the resolution side into line and removes the second hand-rolled copy
that let them drift apart in the first place.

What the undecoded pointer cost

The reported symptom was the loudest of three, and the least damaging. All three are fixed by the
one change, because all three read the same pointer.

	Before	Diagnostic
Schema $ref	Position degraded to any	openapi/unresolved-ref (error)
Discriminator mapping	Mapping entry dropped, union loses a dispatch branch	openapi/unresolved-ref (error)
Identity (any of the above)	One coordinate interned two type nodes	none
Non-schema entries	Anon IDs minted under .../My%2DResp/...	none

The last two rows are the reason this is more than a resolution bug. The pointer returned by
InternalPointer is also an ID source. A pointer through an encoded component name reaches a
position an unencoded pointer also reaches, so the two interned separate nodes — both references
resolving, no diagnostic on either side, and a duplicate that irverify has no reason to call
dangling. For the components that are not schemas it was quieter still: those entries resolve
through the library, so the value arrived intact and no unresolved-ref was ever emitted; only the
pointer stayed encoded, and every ID hoisted beneath it inherited the encoding.

Behavior changes beyond percent-decoding

Two further divergences from the resolver disappear with the hand-rolled split, and are listed
rather than left to be discovered:

• a fragment with leading or trailing whitespace now resolves (the resolver trims it);
• a fragment containing a second # now ends at that #, as the resolver ends it.

Both strictly widen what resolves; no reference that resolved before stops. The document half is
still compared undecoded, which also matches the resolver — it trims that half but does not decode
it, so a self-reference must be spelled the way the file is named. There is a test pinning that
boundary so it reads as a decision rather than an oversight.

Deliberately out of scope

A percent-encoded $dynamicRef fragment still fails to match its $dynamicAnchor. That path is
this compiler’s own anchor index, not the library’s resolver, so the fix there is a decision about
our own behavior rather than one settled by matching a dependency — including whether $anchor
names should be decoded on the declaration side too. Filed as #233.

Test plan

• TestInternalPointer_MatchesTheResolversNormalization (internal/resolve) — pins the
  normalization directly, and deliberately carries the same name as nodeview’s test of the same two
  accessors, so the pair is one grep apart and a dependency bump has to satisfy both. Covers
  %2D/%5F/%2E/%20/%25, an undecodable escape kept raw, %2F deepening the pointer rather
  than naming a component with a slash, whitespace, a second #, and the undecoded document half.
• TestLowerComponentSchemas_PercentEncodedRefResolves — end-to-end for three names that are legal
  under OpenAPI’s own component-name rule (^[a-zA-Z0-9.\-_]+$), so the escape is the only thing
  under test.
• TestLowerComponentSchemas_PercentEncodedRefHoistsAtTheDeclaredCoordinate — the duplicate-node
  case. It puts both spellings in one document deliberately: the encoded ref alone lands on a
  single node whichever way the pointer reads, and only its name is wrong, so a single-spelling
  fixture cannot see the duplicate at all.
• TestLowerService_PercentEncodedEntryRefKeepsTheDeclaredCoordinate — the silent non-schema entry
  case, asserted on the response’s hoisted content schema.
• TestLowerComponentSchemas_PercentEncodedDiscriminatorMapping — the dropped mapping entry.
  InternalPointer’s contract has always named discriminator mappings alongside $ref; nothing
  exercised that half.
• Every new assertion was confirmed to fail against the previous implementation, restored in place;
  the nine pre-existing TestInternalPointer cases (including the #addr anchor refusal from compilers/openapi: an $anchor-resolved schema interns a malformed type ID #141)
  pass unchanged.
• Full gate: gofmt, go vet, golangci-lint (0 issues), go build, and
  ./scripts/check-coverage.sh at 100% of 4224 statements. No golden snapshot moved — no corpus
  spec had used an encoded fragment, which is why the suite was green throughout.