XrdSsi requires that we return data to it as a char* with a size, but
this is not a convenient object for us to fill with data. By creating a
streambuf/ostream wrapper around a char[] buffer we can give XrdSsi what
it needs and use the more convenient stream operators in our own code.

The classes used in this buffer implementation should be moved into the
generic code when I have got the whole thing working.

It turns out my previous comment was completely wrong, and the client in
fact has to allocate the buffer in the case of streams as well as data
Responses.

In the case of a Stream response, XRootD allocates the memory and
manipulates the buffer pointer. In the case of a Data response, we need
to allocate the buffer ourselves. In both cases, the buffer is treated
in ProcessResponseData(), which does not care how the buffer was filled.

This requires a bit of extra logic to make sure the buffer is
deallocated for Data responses but not Stream responses. I have done
this using a unique pointer to allocate a char[] for Data responses.
and char *m_buffer_ptr points to the memory allocated.

We never delete m_buffer_ptr as memory allocation is handled either
by the unique_ptr or by XRoot and we don't care which.

Conflicts:
	xroot_ssi_pb/XrdSsiPbService.hpp

This led to garbage collactor segfaults.

This allows previously developped asyncLockfreeFetch to apply to it.

The previous strategy was made under the assumption that we needed to lock sparingly.
With the introduction of lockfree strategy, this is not true anymore.
The new strategy will be immune from the A watches B, B watches A, both die, and
no one garbage collects them situation (also called cyclers in utility cta-objectstore-unfollow-agent).

This will remove contention on the drive register as drives uipdate their statuses.
Also simplified structures in OStoreDB implementation (less references with added friend relations).

It was lowered during the watch based locking attempt.

This will allow indentification of impacted processes.

The missing unwatch fix should improve performance of watch/notify based locking significantly.
Instrumentation will log any call to rados longer that 1s to /var/tmp/cta-rados-slow-calls.log.
Also prepared a structure to allow switching between watch/notify and backoff based locking.
Backoff code is not yet brought back (will test with the unwatch fix first).

Added Castor_limits.man and source code of Csnprintf

Note that this change is a noop, as the code after compiler preprocessing does not change. This was actually double checked manually.