Support for passing object references over the bridge

Sometimes servicemanager fails to add a name right after startup.

Allows to use different source and destination names.

GBinderProxyObject automatically creates proxies for the remote objects
found in the transaction payload.

In case if looper threads get stuck in read, libgbinder may block
indefinitely in exit. To prevent that, join looper thread with a
timeout and if it expires, close the binder file descriptors to
unblock all blocking reads.

According to comments in the Android sources, unrefs must be processed
only after clearing the incoming command queue.

The driver sends us back one of three transaction completion messages
BR_TRANSACTION_COMPLETE, BR_DEAD_REPLY or BR_FAILED_REPLY after the
target has finished processing BC_REPLY. It's especially important
when the reply carries an object reference. That gives the other side
a chance to reference that object before we drop our reference to it
(which may be the last one, which would cause the object to be freed
and its handle invalidated).

This transaction flag doesn't make sense for replies and is probably
just ignored but let's not confuse kernel.

Otherwise all kinds of race conditions are possible, e.g. with
GBinderServiceManager and its gbinder_servicemanager_died() callback.

That's done by calling test_binder_exit_wait(). Not doing so occasionally
breaks the next unit test.

It's always zero, just leave it as is.

Only affects debug build.

Add GBinderBridge

It acts as a proxy between two binder devices.

This version works for binder transactions which only
pass serialized data back and forth. Passing remote
object references is not yet supported.

This more or less ensures that responses get handled by the right thread
and allows to simulate more sophisticated test cases.

If there's no data, buffer may be NULL.

Fix a threading issue + assorted changes

Make sure that transaction handlers don't get invoked on a worker thread.
It was possible in cases if an incoming transaction arrives while we are
waiting for response from an asynchronous call to servicemanager (which
is actually a synchronous call made on a worker thread).

Invoking callbacks on a worker thread would completely break libgbinder's
synchronization model. It was a pretty unlikely scenario, though.

GBinderFds - native_handle_t
GBinderHidlHandle - struct hidl_handle
GBinderHidlMemory - struct hidl_memory

Except for one-way transactions where it would meaningless.

For better compile time diagnostics.

Also made ServiceManagerAidl a GBinderLocalObject-derived class to prepare
for possibly making it (deriving classes from GBinderLocalObject) a public
functionality.

It's something I've always had in mind. It's still an internal API
but it's quite likely that at some point it will be made public.
For now it's only going to be used by unit tests.

Fix random unit text failures