This avoids the need for a weird struct-as-namespace pattern inside json.capnp.

Features:
- Rename any field or enum value for JSON purposes.
- Flatten structs/groups into their parent object, possibly with a prefix.
- Assign a special discriminant field for unions, so that union members can be flattened without ambiguity.

Disallow copy construction/assignment of (Atomic)Refcounted classes

If a multiply-inherited subclass of kj::Refcounted is move-assigned from an object of its other parent class's type, the reference count would get zeroed out. This change makes such mistakes a compile error.

A bunch of issue fixes for 0.7

On Windows, we don't have `fork()` and `exec()`, but rather `spawn()`, which does both in one call. This makes FD inheritance hard -- the parent process has to set up its own FD table to be what it wants the child to receive, then call spawn(), then set things back.

`capnp` does all that, but there was a problem: when it created a pipe, it failed to set the FDs as non-inheritable (Windows equivalent of CLOEXEC). Thus the child would implicitly inherit both ends of the pipe without knowing it. Since it would never close the write end, it would never receive EOF on the read end.

The fix turns out to be simple: create the pipe non-inheritable. We are already separately using `dup2()` to create the copy of the descriptor that we actually want inherited.

Fixes #488.

Expose CONNECTION_HEADERS_COUNT in http.h

To safely use HttpHeaders::serialize*() with overridden connection-level headers, dependent code must stay up-to-date with any changes in the builtin header list. We now expose CONNECTION_HEADERS_COUNT and its friends to facilitate this.

Work around apparent Clang optimization bug on arm64.

Work around qemu-user mishandling O_TMPDIR.

Implement kj::Table, an alternative to STL maps/sets.

This should be treated as the other end disconnecting, not an error.

This is not related to tables but is needed for the Cloudflare Workers runtime change I'm working on that also uses tables... so I'm throwing it into the same PR.

See map.h changes to see why this makes this cleaner.

This is a very common pattern in practice -- and annoyingly difficult with STL maps.

This required some refactoring so than index.insert() could be called before the row was actually constructed, based on the search parameters.

It also required some awful hacks to support putting the creation function at the end of the argument list to findOrCreate(), with a variable-width arg list before it.

Integer division is really, really slow. The integer hash table benchmark spends most of its time in modulus operations!

This change shaves 32% off the integer hash table benchmark runtime, and 8% off the string hash table benchmark runtime.

This is the very very last command that executes in the Cygwin build, since the next line is disabled. Of course, changing a directory is irrelevant. But that directory doesn't exist after the Cygwin build. So it fails. So the build failed ON THE LAST LINE THAT DIDN'T MATTER ANYWAY.

This reverts commit a5628e469240c3a607758ad39af40500ebb55fd2.

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.

super-test.sh tests building the samples with cmake. Without installing a cygwin-specific cmake, it ends up invoking the Windows-native cmake which doesn't work at all.

Windows -- including Cygwin -- return a NaN representation with the sign bit set, whereas other platforms return one without the sign bit set. This results in different binary output in the JSON-to-binary part of capnp-test.sh.

This was uncovered since we're now runing capnp-test.sh for Cygwin builds, but the problem actually applies to *all* Windows builds. We just weren't running this test for the other builds before.

Interestingly, I *had* run this test with a MinGW cross-compile build running on WINE, and it passed there. Seemingly, WINE's strtod() directly wraps the host system's without trying to emulate Windows differences.

Admittedly this is a strict simplification to the code.

VS 2017 is fine either way.