return_type() is kinda broken in v1.10, see:
JuliaLang/julia#52385

In any case Base.promote_op() is the official public API for this operation so
we should use it anyway.

This always us to handle all the other kinds of task specs.

This should get the docs building again.

Because it doesn't actually do anything now.

Using `myid()` with `workers()` meant that when the context was initialized with
a single worker the processor list would be: `[OSProc(1), OSProc(1)]`. `procs()`
will always include PID 1 and any other workers, which is what we want.

This is a bit nicer than commenting/uncommenting a line in the code.

Otherwise it may spin (see comments for details). Also refactored it into a
while-loop instead of using a @goto.

This is useful for testing and benchmarking.

This is currently necessary for the streaming branch, we'll have to change this
later but it's good to have CI working for now.

This works by converting the output buffers into a safely-serializeable
container and sending that to the new node.

This makes them be displayed as if they were running under the original task.

This makes the tests a little easier to control.

… tasks

Instead of taking/putting values sequentially (which may block), runs
"pull" and "push" tasks for each input and output, respectively. Uses
buffers to communicate values between pullers/pushers and the streaming
task, instead of only using one buffer per task-to-task connection.

Switch from RemoteFetcher to RemoteChannelFetcher
Pass object rather than type to `stream_{push,pull}_values!`
ProcessRingBuffer: Don't exit on graceful interrupt when non-empty

- Added some whitespace.
- Deleted the unused `rand_finite()` methods.
- Allow passing the `timeout` to `test_finishes()`
- Fix bug in one of the tests where we weren't waiting for all the tasks to
  finish, which would occasionally cause test failures because of the race
  condition.

Previously a streaming task calling `Dagger.finish_stream()` would only stop the
caller, but now it will also stop all downstream tasks. This is done by:
- Getting the output handler tasks to close their `RemoteChannel` when exiting.
- Making the input handler tasks close their buffers when the `RemoteChannel` is
  closed.
- Exiting `stream!()` when an input buffer is closed.

`unwrap_nested_exception()` now supports `DTaskFailedException` so we can match
against the real exceptions thrown.