refactor: centralize UTF-16 code-point primitives

[OmarAlJarrah]

This branch bundles two independent changes on top of #44: an internal code-point refactor and a correctness fix to Uri.relativize.

1. Centralize UTF-16 code-point primitives

What

The UTF-16 code-point / surrogate primitives — toCodePoint, appendCodePoint, codePointsOf, charCount, codePointAt, isSurrogatePairAt and their backing surrogate constants — were copy-pasted near-verbatim across the four idna engine files (Idna, IdnaValidity, Normalizer, Punycode) and again in query/QueryParametersBuilder and percent/PercentCodec.

Kotlin's common stdlib has no code-point iteration (Character.toChars / codePointAt are JVM-only), so the shim is genuinely needed — but duplicating the surrogate bit-math 4–5 times is an avoidable drift risk in logic that is easy to get subtly wrong.

Change

Extract a single internal text/CodePoints.kt and route every call site through it.

• IdnaValidity keeps its boxing-free IntArray code-point scan (it's on a hot path), now delegating to the shared toCodePoint.
• Idna.NON_ASCII_MIN and Punycode.INITIAL_N are left separate — same value (0x80), different meaning.
• Constant visibility is narrowest-that-compiles: only the two constants consumers import are internal, the rest private.

Net: ~254 lines of near-verbatim duplication collapsed into one 97-line source of truth. Pure refactor — output is byte-identical for every input.

2. Keep Uri.relativize total when the resolved candidate is invalid

Uri.relativize is documented to never throw, but it could raise IllegalStateException. It verifies its candidate reference by resolving it through the structured Resolver.resolve overload, which raised an internal error when the recomposed target failed to parse. A candidate suffix such as /.//h:zz is a valid rootless reference, but dot-segment removal collapses it to //h:zz, which re-reads as an authority with a non-numeric port and is rejected by the strict parser — so a relativize on two valid URIs (s:/a/b against s:/a//.//h:zz) threw instead of returning null.

The structured Resolver.resolve overload now returns ParseResult<ParsedComponents> rather than raising, and relativize folds a resolution failure (or a non-matching round-trip) to null — the same "no relative form exists" outcome it already returns for its other unreachable cases. The candidate is still resolved from its already-parsed components, so the round-trip stays free of a redundant string re-parse. A regression test pins the /.//h:zz case.

The overload is internal, so there is no public API change.

Safety

Verified on the JVM gate (jvmTest + ktlint + detekt + apiCheck): green, with the IDNA (UTS-46) and NFC conformance suites passing unmodified. Every new or changed symbol is internal, so the public API is untouched (apiCheck passes with no apiDump). The code-point refactor is behaviour-preserving with byte-identical output; the relativize change touches only the error-handling path (a resolution failure now yields null instead of throwing).

Stacked on #44.