NetxNG needs the include directory for XRootD, but when XRootD is
enabled as a builtin, the include directory points to the build
directory and causes CMake to fail with an error like the one below:

CMake Error in net/netxng/CMakeLists.txt:
  Target "NetxNG" INTERFACE_INCLUDE_DIRECTORIES property contains path:

    "${BUILDDIR}/include/xrootd"

which is prefixed in the build directory.

This is a blocker to move to modern CMake constructs (using targets
and properties) for targets that use headers of builtins in their own
headers, as we cannot create imported or exported targets with proper
dependencies.

Should solve different compilation warnings.
Use directly version from head - not waiting for next releasy which
typically happens once a year.

Allows to refuse connection on very early stage

if sender thread was started, one have to call join it - even when
thread function was normally returned

This is special requests, which does not processed immediately but hold
for the long time by the receiver. 

For the moment used in RWebWindow to hold headless browser until
processing is done

Some browsers (like newer Chrome) make fragmentation on chunks of 120KB. 
In the handler one need to combine chunks together before providing to
user code

Instead of starting every new thread for new operation - reuse same
thread which was started during first send operation.

Also take care that such dedicated threads correctly stopped when
WSHandler is destroyed

Only in such mode multithreading is allowed. 
In async mode one can meaningfully use send completion callback.
Default mode is synchronous (as before), which allows to use handler
only from main thread

Before one could submit as many operation as one wants to the websocket.
In case of longpoll socket this lead to extra queue, which was not
controlled by the user. 

Now each send operation is confirmed by callback. Only after such
callback next send operation via websocket is allowed. Queue is
organized externally (like in TWebWindow). 

For the longpoll engine this simplify internal logic and avoids queueing

Now no queues are allowed, all operation are confirmed by WS handler

Now one can directly register WS handlers to THttpServer
If allowed, handlers can be precessed directly in the civetweb threads
without involving of THttpServer thread at all. 
This allows to run many connections for many different web widgets
absolutely independent from each other - there are no one bottleneck in
http thread (or any other main thread)

In that folder all objects are registered, used by THttpServer
This allows to avoid all kind of global lists and exclude interfereance
between different instances of THttpServer. 
Such feature of main importance for TWebWindow(s), which should be
possible to run from many threads without interfearing with gROOT

To avoid 100% of CPU usage, made regulat short sleeps for 1ms

Should be used only with default sniffer, which does not have access to
any global lists

web socket engine should support this (default off) and
web socket handler have to allow this

When using builtin_openssl=ON, CMake erroneously exports the builtin
static libraries in ROOTConfig-targets.cmake, which causes problems with
dependent projects. In order to avoid this, we need Net and RHTTP to use
SSL as a private dependency. Since CMake requires target_link_libraries()
to either be all-plain (as before) or all-keyword (required to allow
PRIVATE linking), we need to move the build system to use all-keyword
linking only.

Fixes: ROOT-9532

Addresses ROOT-9311