Add total client output buffer size to INFO MEMORY

If one (or multiple) clients have large pipeline requests
running (example: 100,000 GETs), now the user can see why
Redis is using more memory than expected.

I experimented with listing the total input buffer size as well,
but Redis consumes input buffers rapidly enough where I
never saw it grow beyond a few KB (and Redis does report
the largest current input buffer as clients.client_biggest_input_buf).

New output for INFO MEMORY:
    used_memory:35054272
    used_memory_human:33.43M
    used_memory_rss:80175104
    used_memory_peak:2830033808
    used_memory_peak_human:2.64G
    used_memory_lua:33792
    used_memory_output_buffers:20516792
    used_memory_output_buffers_human:19.57M
    mem_fragmentation_ratio:2.29
    mem_allocator:jemalloc-3.2.0
Subtract output buffers from eviction calculation

Treat client buffers like we treat Replica buffers
and the AOF buffer by subtracting the total size of waiting output
from the size of the used memory.

The maxmemory directive has a note saying it doesn't take
into account any Replica or AOF buffers (they get subtracted
from the total Redis memory usage calculation for purposes
of determining "maxmemory" for eviction).
But, the eviction process was still counting output buffers
of clients building results to return.

If Redis is configured with an eviction policy and we're
including client output buffers in the total memory usage
calculation, any clients can potentially empty all
volatile keys by issuing large pipleline requests.

Behavior before this commit:
  - maxmemory = 50 MB
  - maxmemory-policy = allkeys-lru or allkeys-random
  - Add 50 MB of data
  - Run a pipeline request of 100,000 GET requests.  The
    output buffers will grow to 200 MB, Redis will
    see the memory usage is now 250 MB, and Redis will start
    evicting keys.  Redis will quickly evict *all* keys because
    evicting keys isn't shrinking the output buffer usage
    in the Redis memory usage calculation.
  - Now the user is left wondering why a series of GET requests
    caused all their keys to expire.

Behavior after this commit:
  - maxmemory = 50 MB
  - maxmemory-policy = allkeys-lru or allkeys-random
  - Add 50 MB of data
  - Issue a pipleline of 100,000 GET requests
  - Redis grows the result set into a 200 MB output buffer,
    but the extra 200 MB isn't included in the eviction calculation,
    so no keys get evicted.
  - All keys remain in place and Redis shrinks back to 50 MB after
    the output buffer is freed.