Batch (and Transaction) dataset_id should match that of Key / Query objects when added

Proposed fix:

Do not ask for dataset_id in the constructor and instead gather it from the keys and queries used in the transaction.

This may require implementing #495 and will require removing the self.begin() call from Transaction.__enter__. (Can't begin until a query or entity is encountered.)

Title was: "Transaction does not rollback correctly when multiple datasets involved"

Witness the following code:

>>> from gcloud import datastore
>>> cnxn = datastore.get_connection()
>>> dataset1 = cnxn.dataset('PROJ1')
>>> dataset2 = cnxn.dataset('PROJ2')
>>> e1 = dataset1.entity('foo')
>>> e2 = dataset2.entity('foo')
>>> e1['bar'] = e2['bar'] = 0
>>> e1.save()
<Entity[{'kind': u'foo', 'id': 5686683802533888L}] {'bar': 0}>
>>> e2.save()
<Entity[{'kind': u'foo', 'id': 5659313586569216L}] {'bar': 0}>
>>> with dataset1.transaction():
...     e1.delete()
...     e2.delete()
... 
>>> e1_still = dataset1.get_entity(e1.key())
>>> e1_still is None
True
>>> e2_still = dataset2.get_entity(e2.key())
>>> e2_still
<Entity[{'kind': u'foo', 'id': 5659313586569216L}] {u'bar': 0L}>

UPDATE: This is because the transaction ignores the dataset associated with e2. To see this, we use the key

<Key[{'kind': 'foo', 'id': 2}]>

in two different datasets and delete the one from dataset2 in the transaction for dataset1. After doing this, we check if that key still exists in dataset1 (it should) and dataset2 (it should, but because the transaction failed since two different datasets were used).

>>> from gcloud import datastore
>>> cnxn = datastore.get_connection()
>>> dataset1 = cnxn.dataset('PROJ1')
>>> dataset2 = cnxn.dataset('PROJ2')
>>> 
>>> e1_1 = dataset1.entity('foo')
>>> e1_1.key(e1_1.key().id(1))
<Entity[{'kind': 'foo', 'id': 1}] {}>
>>> e1_2 = dataset1.entity('foo')
>>> e1_2.key(e1_2.key().id(2))
<Entity[{'kind': 'foo', 'id': 2}] {}>
>>> 
>>> e2_2 = dataset2.entity('foo')
>>> e2_2.key(e2_2.key().id(2))
<Entity[{'kind': 'foo', 'id': 2}] {}>
>>> 
>>> e1_1['bar'] = e1_2['bar'] = e2_2['bar'] = 0
>>> 
>>> e1_1.save()
<Entity[{'kind': 'foo', 'id': 1}] {'bar': 0}>
>>> e1_2.save()
<Entity[{'kind': 'foo', 'id': 2}] {'bar': 0}>
>>> e2_2.save()
<Entity[{'kind': 'foo', 'id': 2}] {'bar': 0}>
>>> 
>>> with dataset1.transaction():
...     e1_1.delete()
...     e2_2.delete()
... 
>>> e1_1_still = dataset1.get_entity(e1_1.key())
>>> e1_1_still is None
True
>>> e1_2_still = dataset1.get_entity(e1_2.key())
>>> e1_2_still is None
True
>>> e2_2_still = dataset2.get_entity(e2_2.key())
>>> e2_2_still
<Entity[{'kind': u'foo', 'id': 2L}] {u'bar': 0L}>

Note that calling beginTransaction requires the dataset ID (we can't do the RPC without it). We already made the dataset ID optional, falling back to the implicit one, but we cannot possibly rely on the keys, because we don't know them yet when we start the transaction.

I think it would be reasonable to say that users who don't want to use the implicit dataset ID know that when they create the batch / transaction, and can easily pass it. We would then change the code in put / delete to reject any key not matching the one set in __init__.