be evil, and make use of the innards of RedisValue to store array data (ref and count) when TypedRedisValue is multi-bulk

# Conflicts:
#	StackExchange.Redis.Server/RedisServer.cs
#	StackExchange.Redis.Server/RespServer.cs

* v0.0 of test server

* server very much doesn't work, but: pieces are in place

* it's alive!

* implement MemoryCache server

* be a little pickier about which faults we actually report

* implement **very badly** pre-RESP protocol for server; this is just to test PING_INLINE etc, and it *finds a catastrophic case*

* make shutdown much more graceful; Databases should be immutable; enable ConnectionExecute vs ServerExecute concept; add awaitable server shutdown task

* make MemoryCache usage standalone, and enable flush; implement cusstom box/unbox operations on RedisValue

* implement basic "info"

* limit scope of GetCurrentProcess

* set slaveof in config to make clients happier

* rename server types; implement MEMORY PURGE and TIME; make types explicit throughout in RedisServer

* implement KEYS; prefer NotSupportedException to NotImplementedException, but recognize both

* implement UNLINK; better handling of nil requests

* implement basic set ops

* implement STRLEN; handle WRONGTYPE

* convention / reflection based command registration

* overhaul how arity works so we can implement COMMAND; support null arrays

* make sure we can parse null arras is RedisResult

* set server socket options

* fix error handling incomplete lines in the "inline" protocol

* move ParseInlineProtocol out, but: still not implemented

* implement CLIENT REPLY and add the "inline" protocol

* need to support either quote tokenizer

* add readme to the server code

* accessibility on sample code

* implement the last of the commands needed for redis-benchmark

* fix naming

* Initial IPv6 connection support

TL;DR: We previously did IP:Port parsing based on splitting at the semicolon...that's pretty hostile for IPv6 and breaks everything. This adopts better parsing from Microsoft.AspNetCore since it doesn't exist in the BCL. The BCL/API conversation is started here: https://github.com/dotnet/corefx/issues/23463

A quick way to test this across all tests is via TestConfig, for example:
{
  "MasterServer": "[::1]",
  "SlaveServer": "[::1]",
  "SecureServer": "[::1]"
}

Note: there's still an Unspecified == AddressFamily.InterNetwork in SocketManager which may be affecting DNS endpoints that are v6...need to look at that next. This change allows actually connecting to an IPv6 endpoint via IP though, that's step 1.

* Move BasicStringGetPerf to non-parallel

* Fix IPv4 assumptions

The socket world has changed - unspecified and dual mode sockets now handle IPv6 correctly. We can just straight up remove the assumption of IPv4 anywhere in code now.

Since this is a race/thread pool thing, we should wait and see if the messges come through rather than assuming any specific time period. This gives more lead time (still capped) while completing the test as fast as possible.

Lots of documentation and formatting fixes, no functional changes.

This is no lonkger flaky...light the test up for Release as well.

include counters from GetOutstandingCount when reporting WriteResult.TimeoutBeforeWrite; include a "what were you doing?" when reporting certain ProtocolFailure exceptions; also, make the IDE happier

rename GetCommands() back to FinishProfiling() (akin to v1); add some obvious methods that avoid LINQ-to-Objects in a few cases, exploiting the fact that we can calculate the count as we reverse the list

move performance completion to start of message completion; fix bug that resurrected result-box; add async profiled test; make all timestamps not throw on duplicates; fake the response received if message aborted (otherwise values can be nonsensical); add aysnc profiled test

Completely rewrite the profiling public API, so that all the external consumer sees is a function that may provide profiling sessions; everything else is the caller's issue; remove all extraneous profiler tracking from the lib

make sure PhysicalConnection doesn't root the multiplexer; this, however, means that every check to the bridge needs to be null-checked

This sets a proper RedisException on the Message, but has the core exception as InnerException as you'd expect.

This also means the Message will have the info we add to it, rather than *sometimes* having it.

Race here