This should allow supporting more versions of Mongo than the existing
mgo driver.

Copying over the filterDBs changes and EnsureIndex fixes from
globalsign/mgo.

Currently Abort is not supported, and it only supports Insert
operations, but the basic layout is plausible and seems like it will
work.

Interestingly, you can't see the documents that you've inserted in the
session that inserted them...

Need to pass in lsid and txnNumber to enable visibility of queries for
things that you just created.

Looks like we finally found the right attributes for where to put lsid
and txnNumber. We now see the right visibility for updates and
insertions. Still need to do Upsert/UpdateAll, etc.

Instead, all the places that were putting a transaction on the op before
submitting it, just use the code path that submits the request to deal
with the transaction.

Also handle if a Session is Closed with an active transaction.
Rework a lot of the Commit/Abort code paths, and make use of the
Session.m object to properly handle Start/Abort/Commit.

Needs tests around Insert/Update/Upsert/Remove/Find and
Start/Commit/Abort sequencing.

These don't actually work because while there may not be a *data* race
in memory, they race eachother for things like 'who is the first to
start the transaction'. They also potentially race around 'is the
transaction finished'.

This might be good enough, as we don't really want to try to make it
possible to do things multithreaded, we just don't want the memory
structures to get corrupted.

One caveat is that the TXN isn't actually started until the first
operation, so it may be that we want to support an outer routine calling
StartTransaction, but it forks off a bunch of helper routines that
are all issued inside the transaction. If we want that, then the best
thing is to probably put a Mutex on the 'transaction' object itself. And
then we need to hold the mutex while the query is being performed, so
that we know we really have issued 'startTransaction' on the remote
side.

Clone doesn't copy the session or transaction, that way we don't have to
worry about txn updates, but also we certainly think that Copy() should
have its own transaction identity. And it makes sense that Clone should
too. Especially we don't want Copy during a txn to behave differently
than Copy outside of a transaction.

Get rid of txn.finished. Let the server decide if the transaction is
active.