Use environment vars to control unit test flags
Fix bugs in JsView

- Fixed incorrect use of local v8 handles.
  Use persistent handles instead.

- Fixed a stack overflow due to Async::whilst
Issue #4: First implementation

Implements a proper transaction protocol:

- Transactions are created using Engine::transaction().
  After that mutations (e.g. insertion and modification of documents)
  can be added to them by calling Engine::updateMutation().

  The effects of such mutations are only visible after the
  transaction has been committed.

- After all mutations have been added the transaction is
  "submitted" by calling Engine::submit(). If this call succeeds
  a following commit will always also succeed. submit() will
  fail if invariants of the transaction are violated, e.g.
  if a document has already been modified by another transaction.

  Adding mutations after calling Engine::submit() is not possible,
  however it is still possible to rollback the transaction.

- Finally Engine::commit() and Engine::rollback() can be
  called to commit or rollback the transaction. This ends the
  transaction's life cycle.

Internally transaction are mostly handled by Engine.
StorageDrivers and ViewDrivers do not care
much about them; they have a single sequence() method that
commits a transaction. Engine is responsible for ensuring that
all preconditions for sequence() are fulfilled. After that
sequence() is guaranteed to succeed.

sequence() may apply a transaction asynchronously;
there are no guarantees when the effects of a transaction will
become visible. However it is guaranteed that all transactions
are applied in the correct order and that they are applied
atomically. That means that Storage- and ViewDrivers have to
do very little to provide a correct implementation:
Simply executing transactions in the order they are
received and making sure no queries are run while a transaction
is applied is sufficient for a conforming implementation.

Engine is responsible for ensuring invariants of transactions:
Making sure that documents exist or that they have certain values
and that those invariants cannot be invalidated
after the transaction is submitted via Engine::submit().

Together these ingredients and multi-versioning (see issue #5)
provide an environment that fulfills the atomicity,
consistency and isolation principles of ACID.
The duration principle can be added by logging
commits to a write-ahead log, see issue #6

What this commit implements:

- The protocol from the beginning of this message

What is left TODO:

- Invariants. Currently submit() always succeeds

- Rollback