Adds a `context` module, which provides several *Context* structs,
intended to bundle together current relevant objects in the hierarchy.
These are meant to replace `worker_getActiveThread`, etc. Passing around
the current context explicitly instead of putting them in globals both
allows us to avoid interior mutability (and its associated runtime cost
and fallibility), and lets us keep a hierarchical object structure (e.g.
allow holding a mutable Process and a mutable Thread belonging to that
process simultaneously).

Most code (e.g. syscall handlers) can take a `ThreadContext` argument
and use that to manipulate anything on the Host. The *current* `Thread`
and `Process` should typically be accessed directly. e.g. since a
mutable reference to the current `Thread` exists at
`ThreadContext::thread`, it *cannot* also be accessible via
`ThreadContext::process` or `ThreadContext::host`.

The manner in which they're unavailable isn't implemented yet, but the
current plan is that they'll be temporarily removed from their
collections. e.g. something conceptually like:

```
impl Process {
    pub fn continue_thread(&mut self, host_ctx: &mut HostContext, tid: ThreadId) {
        let thread = self.threads.get_mut(tid).take();
        thread.continue(&mut host_ctx.add_process(self));
        self.threads.get_mut(tid).replace(thread);
    }
}
```

The Context objects are designed to allow simultaneously borrowing from
multiple of their objects.  This is currently implemented by exposing
their fields directly - Rust then allows each field to be borrowed
independently. This could alternatively be implemented by providing
methods that borrow some or all of their internal references
simultaneously.

Also:

* Move implementations of setActive* and getActive* to Rust Worker.  The
Rust Worker *doesn't* expose references to the active objects themselves
via the Rust API; only to some immutable info about those objects.

* The ShadowLogger now clones an Arc with the relevant Host info,
instead of copying the string name itself and rendering the IP address
from the calling thread. I wasn't sure whether this would actually be a
win or not, but experimentally `make test -j12` is ~2% faster cloning
the Arc than copying the data in both debug and release builds.