Feature Request: Shared buffer pool for multiple clients

[danielchang-Z]

Title: Feature Request: Shared buffer pool for multiple clients

Body:
Currently each chpool.Client holds a dedicated buffer (~100 MiB), which causes very high memory usage (10+ GiB) when maintaining many clients for multi-node inserts. It would be helpful to allow a shared buffer pool (e.g. via sync.Pool or a custom provider) so buffers can be reused across clients.

Repro steps:

for i := 0; i < 20; i++ {
    pool, _ := chpool.New(chpool.Options{ /* connect to node[i] */ })
    // Each pool allocates its own ~100 MiB buffer
}

With dozens of clients, total memory usage grows significantly.

Expected behavior:
Provide an option to configure a shared buffer provider so multiple clients can reuse the same pool of buffers, reducing overall memory overhead in multi-node scenarios.

[mastercactapus]

Running into this too; it also looks like it would be a fair amount of effort to refactor things as the buffer is set upon Dial for the underlying connection and used for the lifetime of each connection.

That said, if you use the connections directly (i.e., implement your own pool) - since you can pass a buffer to DialWithBuffer, you can use sync.Pool and replace the Buffer.Buf

Something like this:

	if len(w.buffer.Buf) > 0 {
		LoggerFromContext(ctx).WarnContext(ctx, "buffer not empty at start of insert, potential memory leak", "len", len(w.buffer.Buf))
	} else {
		buf := writerBufferPool.Get().(*[]byte)
		w.buffer.Buf = (*buf)[:0]
	}
	defer func() {
		if len(w.buffer.Buf) > 0 {
			LoggerFromContext(ctx).WarnContext(ctx, "buffer not fully released, potential memory leak", "len", len(w.buffer.Buf))
			return
		}
		writerBufferPool.Put(&w.buffer.Buf)
		w.buffer.Buf = nil
	}()

	if w.client == nil || w.client.IsClosed() {
		s := time.Now()
		c, err := ch.DialWithBuffer(ctx, w.opts, w.buffer)

While refactoring the client may be a bit of effort, doing something like this around acquiring/releasing connections to chpool might be feasible, and this would be a workaround for direct connections.