This is the shortest route to avoiding double mutable borrows of the
ManagedThread itself.

(This was missing in the C code)

Spawning a thread requires an owned copy of argv; pass ownership all the
way through the stack instead of copying "on-demand".

We currently emulate all the supported operations on these, and ought to
emulate any additional operations we later want to support, if any.

The shmem allocator doesn't support such large alignments. The safe Rust
wrapper panics if the allocation doesn't happen to be aligned enough.

It wouldn't have been giving us this alignment before either; we just
didn't have the alignment validation when going through the C API.

I already suspected the performance difference in the PR this was likely
to have been some other artifact; it seems even more likely now.
Removing it.

Also propagates this backwards a bit for some Thread APIs to take
`&ProcessContext`.

On one hand, this means passing along more "global" state than strictly
necessary. OTOH I think this will help limit the pain of having to
propagate fine-grained requiredments backwards through call stacks when
we need one of these objects in some deeply nested function.

I still left finer-grained parameters for non-pub APIs, since it's not
as painful to refactor those within a single module.

This fixes a FIXME in `Thread` where we were getting the current
`Process` and `Host` from the `Worker`. This propagates passing them
explicitly instead, using e.g. `ThreadContext`.