Don't terminate the process on segfaults.

That is, ensure that memory accesses that might fault in kernel
always use a known instruction so that we can skip this one
and continue executing to e.g. deliver a SIGSEGV to the
process. Additionally, we don't need to note down the resources
we have acquired before performing accesses that might fault,
because we'll always continue and finish the execution of the
kernel-entry (until the SIGSEGV is delivered).
Bugfix: VFSChannel::send returns the msgid now, not 0.
Fixed bug in memory accounting.
Use variables for Thread::resume arguments to ease debugging.
Simplified termination of processes and threads.

Previously, we performed the actual termination in the
terminator-thread, which caused a lot of complications.
Thus, I've changed that now to a much simpler model.
Threads and processes perform the termination now always
on their own. Since we can't release resources like the
kernel-stack at that point, we still use the terminator
to do that. So, the thread releases most of the resources
first, then adds itself to the terminator which will then
kill the thread. As soon as the thread is killed, the
process is notified (e.g. to continue termination of the
entire process). The process is not completely terminated
right away, either, but later by the parent when he
calls waitChild.
If we should terminate a process involuntarily, we don't
do that immediately with this annoying resource-counting
scheme we had before, but we send him the corresponding
signal (to all threads). The threads will then terminate
on their own as soon as it's possible.
Because the termination changed, I also had to adjust some
unittests and especially the way we go into the testsuite,
which is much simpler now and gives us a better environment
(e.g. no temporary kernel-stack).
All in all, this seems to be a lot easier :)