I totally forgot to add wake()s in multiple spots.

This commit does not change any of the code.

A subsequent commit will take advantage of this to apply the exact same tests when an EventPort is in use.

Apparently, this is compatible with older versions of cmake, while having the same effect. Apparently, the cmake people spent some time refuling to let people specify C++ standard versions and instead insisted that they specify specific features instead. They did not see the light until cmake 3.8, but that's too new for us to require yet, I guess.

I'm tired of working around missing features that were added in C++14. It's four years old now, compilers should support it.

Contents of kj-gzip are guarded by KJ_HAS_ZLIB, but the library itself should be still added unconditionally to non-CAPNP_LITE build for tests to link properly.

timer.h takes the place of the old time.h, while time.h itself has been pared down to only non-async-related stuff.

Since async-io.h includes timer.h, I suspect no one will be broken by this change.

I could have instead moved the non-async parts of time.h into a new header to avoid any possibility of breakage, but time.h is the correct name for the core header, and timer.h is the correct name for the async parts (the Timer class)... so I'm risking it.

synchrozines behavior with autoconf build

https://github.com/capnproto/capnproto/issues/515

The Autotools and CMake builds are almost the same, except for
the libraries not being generated as versioned libraries in CMake.

Fixing this lets Linux CMake builds be on the same level as Autotools ones.

In particular: UTF-{8,16,32}, Hex, URI encoding, and Base64

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.

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

This allows functions which use KJ_EXPECT and other test macros to be built without linking libkj-test, which pulls in a possibly-unwanted main() function.

In particular, afl-testcase.c++ could not link in -fno-exceptions mode without this change.

Disallow MSVC from building the parsing code by default because the latest
stable MSVC (VS2015 Update 3) ICEs when trying to compile the `anyOfChars`
combinator.

Note that VS2015 Update 2 and VS2017 can compile the parsing code, with a
little help. To experiment with this, you can override the default
behavior with -DCAPNP_BUILD_TOOLS=ON.

Rename async-io.c++ to async-io-unix.c++, in preparation for factoring out common bits from async-io-win32.c++.

Add missing include when building on Linux

Discovered trying to build on Android using CMake.  UIO_MAXIOV is only
exported by the linux/uio.h header which was never included.  Not sure
how normal Linux builds work.

Add missing reinterpret cast from const void* to const byte*.

Remove -pthread compile flag when building under Android.  ANDROID cmake
variable exported by android-cmake project.

This allows to consumers to use the same targets regardless
whether capnproto CMakeList.txt is added as subdirectory
or whether capnproto is found as package

Consumers of non-installed build directory don't have to manually
set include dirs.

This fixes the lib vs lib64 vs lib32 issue when installing

Other problem with cached BIN_INSTALL_DIR, LIB_INSTALL_DIR, etc options
is that changing official CMAKE_INSTALL_PREFIX variable has no effect.

This makes it a lot easier for CMake based projects to use Cap'n Proto.

Example usage:

find_package(CapnProto)
capnp_generate_cpp(FOO_SRCS FOO_HDRS foo.capnp)
add_executable(foo main.cpp ${FOO_SRCS})
target_link_libraries(foo CapnProto::capnp CapnProto::capnp-rpc)

This is a lot better than the previous variable based solution since
linking to nonexistent targets is an error whereas an empty variable
expansion (e.g. due to typos) will be silently ignored. It also makes
sure that the right compiler flags, include directories, defines and
link libraries are passed to the compiler for that target without
needing any other include_directories(), etc.

A compatibility layer is provided to ease migration.

Thanks to Bryan Boreham <bjboreham@gmail.com> for much help getting this started.

With CAPNP_LITE=1, the command-line tools will not be built, and the
tests cannot be built without EXTERNAL_CAPNP=1 (BUILD_TESTING=0 needs to
be set if the tests are not desired).