breaking: Drop @RPC annotation, use RxRouter.of[T].withPathPrefix(...)

[xerial]

Summary

Revisits the architectural decision from #501. The rest of
`wvlet.uni.http.rpc.*` (`RPCRouter`, `RPCRoute`, `RPCClient`) is
intentionally annotation-free — RPC-ness is determined by which
router class you instantiate. `@RPC` was added in #501 mostly for
parity with airframe; on reflection that conflicts with uni's own
pattern and required a non-trivial annotation-detection branch in the
`RxRouter` macro that the existing Surface metadata didn't need.

Drop the annotation and lean on the convention.

Behavioral changes

• `wvlet.uni.http.rpc.RPC` removed.

• `RxRouter.of[T]` now treats every public method on `T` as a POST
  endpoint, unconditionally. The previous fallback to `@Endpoint`
  scanning is gone — use `Router.of[T]` when you want `@Endpoint`
  routes.

• New builder: `RxRouter#withPathPrefix(prefix)` replaces `@RPC(path)`.

  Before:
  ```scala
  @rpc(path = "/v1")
  trait FileApi:
  def upload(name: String): String

  object FileApi extends RxRouterProvider:
  override def router = RxRouter.of[FileApi]
  ```

  After:
  ```scala
  trait FileApi:
  def upload(name: String): String

  object FileApi extends RxRouterProvider:
  override def router = RxRouter.of[FileApi].withPathPrefix("/v1")
  ```

• `withPathPrefix` on a `StemNode` propagates to all children.

• `@RPC(description = "...")` is dropped; describe via ScalaDoc.

The codegen pipeline (`HttpCodeGenerator` / `ServiceScanner` /
`uniHttpClients`) is unchanged — it never depended on the annotation.
Renamed sbt scripted test `rpc-client-annotated` → `rpc-client-with-provider`
to reflect what it now exercises (an RPC trait whose companion extends
`RxRouterProvider`).

Test plan

• `uniJVM/testOnly wvlet.uni.http.router.RxRouterTest` — 10 tests
  pass (added 3 `withPathPrefix` tests, removed the @RPC-specific
  ones)
• `uniJS/testOnly wvlet.uni.http.router.RxRouterTest` — 10 tests
  pass on Node.js
• `uniNative/testOnly wvlet.uni.http.router.RxRouterTest` — 10
  tests pass

Refs #498. Reverts the annotation portion of #501; keeps the rest of
the runtime API surface intact.

[gemini-code-assist]

Code Review

This pull request simplifies the RPC routing system by removing the @rpc annotation requirement and introducing a convention-based approach where all public methods are exposed as POST endpoints. It also adds a withPathPrefix method for manual namespacing. Key feedback includes addressing a visibility issue for macro-expanded code, ensuring withPathPrefix supports additive nesting to prevent overwriting existing prefixes, and optimizing route generation performance using lazy val in both EndpointNode and StemNode.

[gemini-code-assist]

The visibility of ObjectMethodNames is restricted to private[router]. However, this set is referenced inside a macro quote ('{ ... }) in buildRxRouterImpl. When the macro is expanded at a call site outside of the wvlet.uni.http.router package, the generated code will fail to compile because it cannot access this private member. Please make this member public or move it to a location accessible by the macro expansion.

  val ObjectMethodNames: Set[String] = Set(

[gemini-code-assist]

The current implementation of withPathPrefix in EndpointNode overwrites the existing pathPrefix instead of prepending to it. This causes issues when withPathPrefix is called on a StemNode (which propagates the call to its children) if those children already have their own prefixes defined. The prefixes should be additive to support proper router nesting.

    override def withPathPrefix(prefix: String): RxRouter =
      val newPrefix = if pathPrefix.isEmpty then prefix else s"${prefix.stripSuffix("/")}/${pathPrefix.stripPrefix("/")}"
      copy(pathPrefix = newPrefix)

[gemini-code-assist]

The toRoutes method performs duplicate detection and path generation every time it is called. Since RxRouter definitions are typically static and the underlying surfaces are immutable, it is more efficient to use a lazy val to cache the resulting sequence of routes.

    override lazy val toRoutes: Seq[Route] =

[gemini-code-assist]

Similar to EndpointNode, StemNode.toRoutes performs a flattening operation on every call. Using a lazy val here will cache the combined routes from all children, improving performance when the router is accessed multiple times.

    override lazy val toRoutes: Seq[Route]                     = children.flatMap(_.toRoutes)