Extend totalSizeInWords() to also return a count of capabilities, which helps when a separate capability table needs to be allocated as well.  Use this in the RPC system.

Optimize promise tail calls by making ChainPromiseNode automatically detect and remove redundant nodes.

Make all Promise methods consistently consume the promise (returning a new promise when it makes sense), rename daemonize -> detach, and make eagerlyEvaluate() require an error handler (this caught several places where I forgot to use one).

Overhaul the way EventLoop is specialized so that it's possible to hook up to an existing event loop infrastructure that is not KJ-aware.  This also makes the async IO API more dependency-injection-friendly.

Revamp concurrency model, part 1:  EventLoop no longer allows cross-thread event queuing, simplifying many things.  Capability clients are no longer thread-safe, so they don't have to be so const.  In the future, explicit ways to communicate between threads will be re-added, but threads will be treated more like separate vats that just happen to have a particularly fat pipe.  Upcoming:  Remove mutexes.

Make EventLoop current when constructed, so that you can use the Promise methods even when the loop hasn't actually started yet.

Implement exclusive promise joining:  Join two Promise<T>s to create a Promise that resolves when either input resolves.

Refactor capability code using fork.  Still too much refcounting, though.  Maybe this calls for a different design for pipelining...

Using promises for references to represent each branch of a fork doesn't work, because the fork hub will be deleted when the last branch resolves, before any continuation can run.  Instead, let's just institutionalize the concept of addRef() for owned pointers.

Improve and simplify event ordering.  When explicitly calling an EventLoop, events are now always added to the end of the queue, ensuring deterministic run order and making yield() obsolete.  OTOH, then() may queue events to run immediately, preempting other events.