[Feature] Add an extension point for client connection pooling

[yarolegovich]

a2aclient.WithConnectionPool() factory option can simplify connection reuse for integrations like ADK RemoteAgent, where constructor takes an AgentCard and opens a connection on invocation.

Connection pooling improves application performance by reusing existing connections instead of creating new ones, which reduces overhead and speeds up response times.

[yarolegovich]

This is mostly related to gRPC transport where grpc.NewClient is invoked to on new client creation. The call creates a ClientConn which can be long-lived:

// A ClientConn encapsulates a range of functionality including name
// resolution, TCP connection establishment (with retries and backoff) and TLS
// handshakes. It also handles errors on established connections by
// re-resolving the name and reconnecting.

The current API is flexible enough for users to create a factory which will be caching connections by interface URL, so this ticket is more about avoiding hidden performance costs with the default configuration.

The proposal is to add something like:

type GRPCConnectionPool interface {
	Acquire(url string) (*grpc.ClientConn, error)
	Release(*grpc.ClientConn) error
}

func WithPooledGRPCTransport(pool GRPCConnectionPool) FactoryOption {
	return WithTransport(
		a2a.TransportProtocolGRPC,
		TransportFactoryFn(func(ctx context.Context, url string, card *a2a.AgentCard) (Transport, error) {
			conn, err := pool.Acquire(url)
			if err != nil {
				return nil, err
			}
			return &grpcTransport{
				client:      a2apb.NewA2AServiceClient(conn),
				closeConnFn: func() error { return pool.Release(conn) },
			}, nil
		}),
	)
}

With the default GRPCConnectionPool implementation configurable with released connection TTL.

It also probably makes sense to extract grpc transport into a separate package similar to how it's done for server. The reasoning for keeping it in a2aclient was that we initially planned to support just grpc for the first realease.