First attempt at the call shunting in C

This should make a little C interface library called grustna
(with a wink to my Russian friends).
Erased the global loop thread

We can live off GLib's poll context system without an extra thread.
The Rust wrappers for refcounted objects will keep the context of
their creator thread's local context to achieve safe cross-thread use.
Warn about calls aborted due to the context going away

We want an error status returned to Rust so it can properly fail, too.
A pessimized implementation of thread-safe calls

Since the call closures _may_ be invoked in the context of another task,
it's a bad idea to pass them mutable pointers to on-stack boxes.

The wrapped objects now hold references to the default GMainContext
of the thread they were obtained in. The context pointer is woven
through the Rust <-> GLib interface to ensure that no objects are
used outside of their GMainContext. If needed, a call is dispatched
through the GMainContext in another thread.
Exported on- and off-stack call paths to Rust

So that Rust code gets to use stack closures
with the fast on-stack call path.
Some support for debug builds

Now you can do `make BUILD_OPTIONS=debug`.
Debug printouts for refcounting
Disable gdbus/gvfs usage when running tests

The gvfsdbus backend adds a lot of runtime state and activity
highly dependent on local configuration. Even if it may reveal
problems in our event loop code, the added noise and lack of
predictability is unwelcome for testing and the debug tools.
Added an ignored test for off-stack calls

This test crashes due to a compiler bug,
and running tests in parallel results in
a hang-up, possibly due to a race in g_type_init().
Serialize the test run

It's pretty bad form that grust::init() is not reentrant.
But even though that should be fixed, running tests in parallel
creates unpredictability in on-stack vs. off-stack paths that
contest the default GMainContext. I should think about isolating
the tests better, as surely parallel test runs are a good stress
test for thread safety.
Added a couple more tests that don't crash
Autotoolize
Dropped in autogen.sh from buildconf

My Eclipse seems to dig it.
More uniform dependency tracking
Aggressively try on every turn to run the call on stack

We really want to, otherwise we end up doing expensive things
like copying stuff to owned closures on the Rust side, and
minder threads (to be added next).
A more-or-less debugged cross-thread call implementation

Pooled call minder threads now wait with exponential backoff
timers to drive the call to completion in case no other thread
has done so.
g_type_init() was completely blameless.
Small fixes to the build rules
Do serial and parallel test runs, selectably
Added -Wall -Werror to the C compiler flags
Give each Rust thread its own GMainContext

For call with no context previously associated.
Otherwise the calls all end up contesting the default context.

This could be a nice way to impose the inherent parallelism of a
Rust program on the GLib objects it uses.