Run proxied VTABLE methods with the threads interp

Even read only methods can cause garbage collection (e.g. with parameter
passing). This would have catastrophic results, since a foreign thread
would be running this GC and it would find both threads' PMCs. Even
worse, the proxied interp could be running the GC at the same time.

Blocking the foreign GC is not possible without lots of locking since
even if we Parrot_block_GC_mark, the foreign interp could already be
running its GC.

Running the method with the thread's interp seems like the smaller
problem. The interps are closely related, so the data the method needs
should be available (and well suited to the caller). On the other hand
we no longer can unconditionally create proxies for all returned PMCs
since those could as well have been created by the call and would now
belong to the thread's interp. So we now check the PMC's orig_interp and
use it to decide if we need to create a proxy.

Since this enlarges every PMC by a pointer, this has some negative
impact on performance. A possible optimization could be to tell the GC
to set a flag on all newly created PMCs since we don't need to know
which interp exactly created the PMC, just if it was the current one.

We still have to block GC since during the call foreign PMCs might be on
the C stack which should not be handled by our GC.
Lock the proxied interp while scheduling a task

Scheduling a task could cause garbage collection. To be able to savely
disable the GC the proxied interp must be in a known state, so we have
to lock it. Same mechanism is already used for thread interps. Just do
the same for the main thread.
Don't exit a thread if no tasks are running

Keep threads running even if no tasks are in the queue since the main
thread may schedule new tasks any time.
Example programs using threads

Just some examples to show how Tasks and threads might be used.
Fix unwrapped macro args
Decrease readability to satisfy coding standards
Remove trailing whitespace
Add new example files to MANIFEST
Merge branch 'master' into threads

Conflicts:
	src/gc/gc_ms2.c
	src/scheduler.c
Add a dependency so that t/src/checkdepend.t again passes.
[codingstd] Make file pass c_parens standard.
[codingstd] Make api.h pass c_parens and c_operator tests.

It's still failing c_macro_args due to "PARROT_STATIC_ASSERT has unwrapped arg: X".
add parens to humor codetest
Merge branch 'kid51/makefile_variables'
Parrot's Test::More is not ready for threads (writes to shared data)
Fix Parrot_pmc_get_type_str when the class hash is a Proxy
Don't create proxies for PMCNULL
Unbreak the parrallel build by making prt0* depend on miniparrot
Fix the wait op for threads

A task scheduled on another thread will get cloned to be local to this
thread. The two task objects are then linked by a "partner" pointer. To
wait for a task of another thread one now only has to add the current
task to the waiter list of the original task object.

A task will schedule its waiters when it is done and now will also see
if the partner task has any waiters and schedule them on the partner's
interp.

In addition the main thread will now no longer exit as long as tasks on
other threads are running (an explicit exit op does still work however).
The main thread's tasks could still be waiting for other tasks to
finish.
Fix documentation to match the VTABLE function names they document