pub fn run_async(
		&self,
		fun: impl (FnOnce(&JobTaskContext<'_>) -> Box<dyn Future<Output = ()> + Send + Sync>)
			+ Send
			+ Sync
			+ 'static,
	) -> Ticket {
		self.control(Control::AsyncFunc(Box::new(fun)))
	}
Run an arbitrary function and await the returned future.

The function is given [`&JobTaskContext`](JobTaskContext), which contains the state of the
currently executing, next-to-start, or just-finished command, as well as the final state of
the _previous_ run of the command.

Technically, some operations can be done through a `&self` shared borrow on the running
command's [`TokioChildWrapper`], but this library recommends against taking advantage of this,
and prefer using the methods on here instead, so that the supervisor can keep track of
what's going on.

A gotcha when using this method is that the future returned by the function can live longer
than the `&JobTaskContext` it was given, so you can't bring the context into the async block
and instead must clone or copy the parts you need beforehand, in the sync portion.

For example, this won't compile:

```compile_fail
# use std::sync::Arc;
# use tokio::sync::mpsc;
# use watchexec_supervisor::command::{Command, Program};
# use watchexec_supervisor::job::{CommandState, start_job};
#
# let (job, _task) = start_job(Arc::new(Command { program: Program::Exec { prog: "/bin/date".into(), args: Vec::new() }.into(), options: Default::default() }));
let (channel, receiver) = mpsc::channel(10);
job.run_async(|context| Box::new(async move {
if let CommandState::Finished { status, .. } = context.current {
channel.send(status).await.ok();
}
}));
```

But this does:

```no_run
# use std::sync::Arc;
# use tokio::sync::mpsc;
# use watchexec_supervisor::command::{Command, Program};
# use watchexec_supervisor::job::{CommandState, start_job};
#
# let (job, _task) = start_job(Arc::new(Command { program: Program::Exec { prog: "/bin/date".into(), args: Vec::new() }.into(), options: Default::default() }));
let (channel, receiver) = mpsc::channel(10);
job.run_async(|context| {
let status = if let CommandState::Finished { status, .. } = context.current {
Some(*status)
} else {
None
};

Box::new(async move {
if let Some(status) = status {
channel.send(status).await.ok();
}
})
});
```
crates/supervisor/src/job/job.rs