Don't sleep forever unless there is a reason to.

This bug was fairly hard to track. First, the most important task of fluxcapacitor is to just run the processes underneath. That means forwarding the syscalls to and from the kernel. Secondary objective is to keep track of who is currently blocking. When all processes are blocking fluxcapacitor may decide to accelerate the time.

That may not always be optimal. If the timeout for acceleration is very small it may make sense to just wait for a while until the time has passed.

But it doesn't. Before we did uevent_select(, NULL), which meant we would wait for _infinite_ time for next event. Let me rephrase: we decided all processes are blocked and we could increase time, but decided to wait for next event instead. We'll end up waiting for a pretty long time if nothing external happens, as we will be woken only when kernel decides that a timeout expired. Which timeout? exactly, it's pretty random as the kernel doesn't know about our time speedup.

Before this patch fluxcapacitor wasn't always speeding up the time where it could.
Remove idleness timeout, refactor main event loop.

Before speeding up time we need to make sure there aren't any data interlocked within the kernel. We must make sure every child process received all data available. For this we did two things: run sched_yield() and wait for idleness_threshold timeout.

The problem is: waiting takes a lot of time!

Instead we're going to have a different technique now: we're going to relay solely on sched_yield. No timeout will be used.

Effectively fluxcapacitor now should always busy-loop.

The only exception is processes waiting on an unknown blocking syscall.
Cosmetic. Better log messages.