api: add PoolAllocator for response buffers

[ermyar]

The new Allocator interface allows users to implement custom buffer
allocation and reuse strategies:

// Allocator is an interface for allocating and deallocating byte
// slices.
type Allocator interface {
    // Get returns a pointer to a byte slice of at least the given
    // length.
    // The caller should not assume anything about the slice's
    // capacity.
    //
    // If the allocator cannot allocate a buffer (e.g., invalid
    // length), it returns nil. The caller must handle this case
    // appropriately.
    Get(length int) *[]byte
    // Put returns a byte slice to the allocator for reuse.
    // After calling Put, the caller must not use the slice.
    //
    // The caller must ensure that the slice length remains unchanged
    // between Get and Put calls. Modifying the slice length before
    // calling Put may prevent the allocator from properly reusing the
    // buffer.
    Put(buf *[]byte)
}

The PoolAllocator type provides a ready-to-use implementation based
on sync.Pool for power-of-two sized byte slices.

The Opts.Allocator option enables configuring a custom allocator
for a connection. This is useful for applications that need to
optimize memory usage or integrate with custom memory management
systems.

Closes #493

• Tests (see documentation for a testing package)
• Changelog (see documentation for changelog format)

[oleg-jukovec]

Please, rebase the PR.

[oleg-jukovec]

Thanks for the patch!

Except for the comments, everything is fine here. But let's improve the solution a bit here before merge.

Let's use the approach from the grpc-go:

https://github.com/grpc/grpc-go/blob/master/mem/buffer_pool.go

Create multiple buffers with constant byte sizes instead of the single one. Response that does not fit into these buffers should be allocated separately without a pool and without a release.

It shouldn't be copy-paste, but inspirated the go-grpc's code.

Another option is that you can correct the current comments and we will merge the PR, and you will implement logic with buffer pools in another one.

[oleg-jukovec]

1. If a user do not use the Release() than the commits adds +1 allocation per request. Let the pool be a configurable feature with Opts. enabled by default.
2. We need to update our code (in pool, queue, crud etc.). To release requests to be consistent with the feature.