Add kotlinx-rpc gRPC integration

[andrewparmet]

• Add grpcKrpc generation flag that emits @Grpc-annotated Kotlin interfaces from proto service definitions
• The kotlinx-rpc compiler plugin processes these interfaces at compile time, synthesizing stubs, service descriptors, and method descriptors
• New protokt-runtime-grpc-krpc published module: marshaller bridge between protokt serialization and kotlinx-rpc's GrpcMarshaller interface
• Working HelloWorld example with passing multiplatform test (JVM + native) using kotlinx-rpc GrpcServer/GrpcClient
• Third-party variant for vendored common protos (proto-google-common-protos-grpc-krpc)
• Remove Generate.all() convenience method (misleading with multiple mutually exclusive gRPC backends)
• Add Generate.grpcKrpcLite() and Generate.grpcKotlin() convenience methods
• Replace @OnlyForUseByGeneratedProtoCode on AbstractDeserializer/AbstractMessage with @SubclassOptInRequired so users don't need opt-in to use generated companions as Deserializer<T>

Standalone example

The kRPC example lives in standalone-examples/grpc-krpc/ as its own Gradle build (mirroring gradle-plugin-integration-test/). This is necessary because the kotlinx-rpc compiler plugin resolves as {kotlinVersion}-{rpcVersion}, permanently coupling its Kotlin version to kRPC's release cadence and we don't want to be bound to that cadence.

What protokt generates (from hello_world.proto):

@Grpc(protoPackage = "helloworld")
public interface Greeter {
  public suspend fun SayHello(message: HelloRequest): HelloReply
}

Streaming methods (from route_guide.proto):

@Grpc(protoPackage = "io.grpc.examples.routeguide")
public interface RouteGuide {
  public suspend fun GetFeature(message: Point): Feature              // unary
  public fun ListFeatures(message: Rectangle): Flow<Feature>          // server streaming
  public suspend fun RecordRoute(message: Flow<Point>): RouteSummary  // client streaming
  public fun RouteChat(message: Flow<RouteNote>): Flow<RouteNote>     // bidi
}

What the kotlinx-rpc compiler plugin generates from that:

• Greeter$$rpcServiceStub: implements Greeter, delegates calls through RpcClient
• Greeter$$rpcServiceStub$Companion: implements both RpcServiceDescriptor<Greeter> and GrpcServiceDescriptor<Greeter>, provides delegate(marshallerResolver, config) for wiring method descriptors and marshallers

User-facing API:

// server
val server =
    GrpcServer(port) {
        messageMarshallerResolver = resolver
        services {
            registerService<Greeter> { GreeterService() }
        }
    }
server.start()

// client
val client =
    GrpcClient("localhost", port) {
        messageMarshallerResolver = resolver
        credentials = plaintext()
    }
val greeter = client.withService<Greeter>()
val reply = greeter.SayHello(HelloRequest { name = "world" })