Simple netty based HttpClient

[kasobol-msft]

This PR has a prototype of a lightweight HttpClient based on Netty .
This prototype aims to build an http client that works for various types of payloads and context (sync vs async) and mostly serve sunny day scenarios while introducing all the required complexities to do so.
There's a lot of corner (mostly error) cases that remain uncovered here, but they likely won't affect existing complexity much.

Implemented features:

• Reactor-less sync execution. Sync-over-async on the CompletableFeature instead.
• Connection Pooling
• Buffered requests handling
• Stream-able requests handling
• On demand response buffering
• Piped based response streaming for sync calls
• Sink based response streaming for async calls (there's still plenty room for improvement here around better backpressure handling).

The client seems to be functional, i.e. SimpleNettyHttpClientHttpClientTests extends HttpClientTests and SimpleNettyHttpClientRestProxyTests extends RestProxyTests are passing.

[azure-sdk]

API changes have been detected in com.azure:azure-core. You can review API changes here

[azure-sdk]

API changes have been detected in com.azure:azure-core-http-netty. You can review API changes here

API changes

+     public class SimpleNettyHttpClient implements HttpClient {
+         public SimpleNettyHttpClient() 
+         @Override public Mono<HttpResponse> send(HttpRequest request) 
+         @Override public Mono<HttpResponse> send(HttpRequest request, Context context) 
+         @Override public HttpResponse sendSynchronously(HttpRequest request, Context context) 
+     }

[azure-sdk]

API changes have been detected in com.azure:azure-core-test. You can review API changes here

[anuchandy]

A recommendation in "Effective Java (EJ)" while following DCL is to introduce a local variable. As per the EJ, such a version may improve the perf by about 25% compared to the version without the local variable.

The code would be (pattern copied from EJ)

public void collect(ByteBuf buffer, boolean isLast) {
    if (buffer.isReadable()) {
        ByteArrayOutputStream result = ensureStream();
        try {
            buffer.readBytes(result, buffer.readableBytes());
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }
}

private ByteArrayOutputStream ensureStream() {
    ByteArrayOutputStream result = outputStream;
    if (result == null) {
        synchronized (this) {
            result = outputStream;
            if (result == null) {
                outputStream = result = new ByteArrayOutputStream();
            }
        }
    }
    return result;
}