* Announce 0.6 release on blog, and update site.

* When pushing capnproto-next site, include future blog posts.

* Deeper headings.

* Linkify people's names to Github profiles, and finish sentence about JSON.

* Link to exact second in JGC video.

This will break out MinGW, VS2015, and VS2017 builds into separate jobs.
While they will still probably build in serial, we'll at least get better
granularity on test results.

Update outdated comment, and require CMake 3.1, which allows us to take
advantage of target_compile_features.

Projects which use Cap'n Proto require C++11, because they must be able to
compile our headers. Old gcc defaults to C++98, forcing users to manually
specify the -std=gnu++11 flag in their CMake projects. CMake 3.1
introduced the target_compile_features command which removes this
necessity by automatically communicating the C++ standard level
requirement to client projects.

Specifically, if target `kj` requires a C++11 feature publicly, then all
targets which link to `kj` will also require that C++11 feature, and get
the -std=gnu++11 flag for free. If that target is a library, such as
`kj-async`, and `kj-async` links publicly to `kj`, the requirement is also
transitive to all targets which link to `kj-async`.

Note that CMake's default behavior is to request compiler-specific
extensions, such as those provided by the -std=gnu++11 flag. You must
specifically opt out of these extensions. I'm not aware of any way to
propagate this nuance in CMake, but added a check to at least prevent
users from compiling Cap'n Proto without extensions.

With this change, the c++/samples/CMakeLists.txt will build with MinGW
with no change beyond requiring a later version of CMake.

VS2015 only barely compiled ~NullableValue's noexcept specifier
expression. VS2017 can't at all, so we're going with noexcept(false) for
MSVC for now.

Have AppVeyor run the tests.

I can only reproduce this failure on AppVeyor, but the test prints:

capnp\rpc.c++:2886: exception = kj\async-io-win32.c++:399: failed: WSASend(): A request to send or receive data was disallowed because the socket had already been shut down in that direction with a previous shutdown call.

I think this is because WSAESHUTDOWN was considered to be a "bug" exception rather than a "disconnected" exception. It is odd, though, that it doesn't happen when I run locally.

On Linux this cuts 56% off the run time of the fuzz test (aka 2.28x speedup).

On Windows this makes it practical to run the fuzz test at all -- previously it was wayyyyyyy too slow.

While the VS2015 build no longer depends on the MinGW installation as an
external capnp, I think testing the CMake MinGW build on Windows probably
remains worthwhile.

This option was only useful when MSVC couldn't build the capnp command
line tools, so let's back it out.

The previous solution used hard-coded paths which would have had to be
special-cased for multi-configuration generators such as Visual Studio,
which put binaries in individual Debug, Release, etc. directories.

MSVC as of VS2015 does not initialize the vtable pointers of constexpr
objects, causing nullptr dereferences at runtime. To solve this, we can
just convert them to regular const variables with internal (static)
linkage.

The internal linkage bit is important: as long as they are invisible
outside their respective translation units, we do not risk the static
initialization order fiasco.  If we ever need to reference them outside
their translation units, we would need to hide them behind functions (like
HeapArrayDisposer::instance()) to keep things safe.

This works around an issue which prevented kj::parse::ref() from compiling.

The fix in ae6b4452 worked for getting the HTTP code building, but was
apparently insufficient for the capnp command line tools.