Add a public pluralization hook so language packs can render correct plurals

[nemezida1337]

Context: I maintain a language pack for DSH — an external client plugin that adds Russian to the web UI (3058 interface strings and 421 plugin display strings, https://github.com/nemezida1337/dsh-locale-russian). It works on 0.1.5-rc.x and 0.2.1-rc.2 and passes its checks on Linux and Windows, but it runs into two things an external plugin cannot reach around. Both are below with code references.

Summary. The locale catalog is documented as extensible, but the runtime has
no plural selection, so a language pack cannot render languages whose plural
rules differ from English.

What happens today. LocaleRuntime.translate resolves exactly one template
per key:

// packages/client/locale/src/client/index.ts:466
private translate(ns: string, key: string, params?: Record<string, unknown>): string {
  const chain = this.fallbackChain(this.snapshot.active)
  const template = this.lookup(ns, key, chain)
    ?? (ns !== COMMON_NS ? this.lookup(COMMON_NS, key, chain) : undefined)
    ?? key
  if (!params) return template
  return template.replace(/\{(\w+)\}/g, (match, name: string) =>
    name in params ? String(params[name]) : match)
}

Components choose the grammatical form themselves, by English rules — for
example packages/client/ui-trajectory/src/client/TrajectoryTable.tsx:

t(steps === 1 ? 'summary.steps.one' : 'summary.steps.other', { count: steps })

Russian has three categories (1 файл, 2 файла, 5 файлов; 21 файл, 22 файла,
25 файлов), so count === 1 ? one : other cannot express it. The .one/.other
key pairs are already in the dictionaries, but the selection lives in component
code, outside anything a language pack can reach.

Workaround a language pack needs today. Wrapping the private prototype
method and encoding up to three |-separated forms per dictionary value:

const original = Object.getPrototypeOf(locale).translate
Object.getPrototypeOf(locale).translate = function (ns, key, params) {
  // observe Intl.PluralRules('ru') over params.n/params.count and pick a form
}

That works (our pack ships it), but it depends on an internal method name, its
argument order, and its interpolation rules — none of which are part of the
language-pack contract. A rename or a signature change breaks every pack that
supports a language with non-English plural rules, and the failure is silent:
copy keeps rendering, only the agreement degrades.

Proposal. Pick one of:

1. A registered plural selector: ctx.locale.addPluralRules({ id: 'ru', select(count) { … } }),
   applied inside translate for keys whose value carries multiple forms; or
2. Function values in a dictionary ((count, params) => string) for keys that
   need agreement; or
3. At minimum, document the |-separated multi-form convention as part of the
   public dictionary contract and keep translate's signature stable.

Compatibility. Any of the three is additive: English and Chinese dictionaries
keep single-form values and the existing .one/.other selection keeps working
unchanged.