fix(rpc): close the service-collision fail-open and the fix-wave gaps

Critical:
- router: fail loudly (WRN-SERVICE-COLLISION) when two app/services files
  scan to the same service name, instead of silently letting directory-walk
  order pick a winner.

Important:
- server.ts: wrap a throwing input schema so its raw message cannot escape
  invoke(); returns RPC_INVALID and logs server-side instead.
- client.ts: race timeoutMs against transport.call so a stalled transport
  cannot hang the caller; rejects with a ServiceError(RPC_TRANSPORT).
- client.ts: the proxy returns undefined for undeclared properties (incl.
  then/catch/finally) instead of a function that throws, closing the
  await-client thenable trap.
- gateway.ts / rpc-dispatch.ts: import RPC_PATH_PREFIX / RPC_INTERNAL_HEADER
  from @wrnexus/rpc instead of hardcoding local copies.
- gateway.test.ts: cover the RPC-prefix edge block and internal-header
  stripping across casing variants.
- http.test.ts / client.test.ts: cover anonymous-call header omission, the
  internal marker, the retryable-status sweep, network/malformed/HTML
  failures, AbortSignal propagation, the timeout path, and timer cleanup.

Minor:
- transport.ts: Object.hasOwn for handler lookup; note the entry-only abort
  check.
- client.ts: wrap a missing/invalid WRNEXUS_RPC_SECRET as a ServiceError
  (RPC_IDENTITY) instead of a bare Error.
- rpc/package.json: drop the unused @wrnexus/authz dependency.
- server.ts: implement() now throws at construction time if a declared
  procedure has no own handler.

Verified: reverting the service-collision check and the client timeout race
each make their new test fail, then restore green.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

packages/rpc/src/transport.ts

@@ -25,8 +25,16 @@ export type InProcessHandler = (
 export function inProcessTransport(handlers: Record<string, InProcessHandler>): Transport {
   return {
     async call(target, payload, options) {
+      // Checked only at entry: this in-process transport does no I/O, so
+      // nothing yields between here and the handler call below, and a signal
+      // that aborts mid-flight is never observed. In-process tests therefore
+      // cannot exercise a mid-call timeout path — that needs a real transport.
       if (options.signal?.aborted) return failure(RPC_ERROR_CODES.transport, "Call aborted");
-      const handler = handlers[`${target.service}/${target.procedure}`];
+      const key = `${target.service}/${target.procedure}`;
+      // Object.hasOwn, not plain indexing: a prototype-inherited key (e.g.
+      // "constructor/toString") would otherwise resolve to a function that
+      // is not one of our handlers.
+      const handler = Object.hasOwn(handlers, key) ? handlers[key] : undefined;
       if (!handler) return failure(RPC_ERROR_CODES.unknown, "Unknown procedure");
       try {
         return await handler(payload, options.identity);