Still TODO:

- We need to handle disembargos with target = (importedCap = ...).
- Testing.

The := below is sufficient, since this isn't actually used before that.

Needs testing.

This caught a bug: we need to check if ClientState.Metadata is nil,
which is possible if the client itself is null, and seems to happen to
the promise after it is resolved.

TODO: we should de-dup the logic between releaseExport and
releaseExports. This is not entirely trivial though, because the
latter is executed after we've wiped the exports table.

These are much cleaner.

...now that the resolver takes ownership.

Worryingly, this was manifesting in the test as a deadlock: we hit the
error complaining about it not being an import, but then connection
shutdown hung, waiting on tasks. I haven't pinned down exactly what was
going on there, but this sidesteps the issue by fixing the thing that
was causing a connection abort in the first place.

Push the logic for flushing the answerqueue into the Promise type
itself. This is much cleaner, and avoids some racy logic that I'm not
sure was correct.

...instead of a Client. This is a step towards addressing the tribble
4-way race condition. Currently there are some test failures.

The call to waitRef.Release() in export.go was resolving the receiver
too soon, resulting in a leak.

Has build errors that need fixing.

I plan on adding *Snapshot versions and eventually storing snapshots
internally.

This seems like an unnecessary complication, and I don't want to deal
with it when porting stuff over to snapshots.

...and use it to catch a bug; the test is failing, need to track it
down.

Otherwise the target message steals the caps, resulting in errors
later when we try to read them.

Per capnproto#523, this is currently failing frequently. Mark it as flaky
until we're ready to actually deal with it.

In addition to letting us hand out borrowed references, Storing the
snapshots will facilitate code that needs them not to resolve further
after AddSnapshot() or SetSnapshot().

There are test failures that need debugging though.