Add functions to report total client buffer sizes

It's useful to be able to see how much memory is used by
large output or input buffers.
Add total client output buffer size to INFO CLIENTS

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 CLIENTS (with no activity):
    # Clients
    connected_clients:1
    client_longest_output_list:0
    client_biggest_input_buf:0
    output_buffers_used_memory:0
    output_buffers_used_memory_human:0B
    blocked_clients: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.