Background (How Datastore Concurrency Works)

When a client updates records inside a Datastore transaction, the Datastore backend places an invisible transaction lock on those records. This prevents other transactions from making concurrent/conflicting changes.

These locks must be released as quickly as possible to avoid "database traffic jams":

1. If the transaction succeeds, it commits the changes and releases the lock.
2. If the transaction fails or is canceled, the client library must send a "Rollback" RPC. This tells Datastore to discard the changes and release the lock immediately.

The Bug

When users set a transaction timeout (e.g., using a 5-second context limit) and a Commit is slow or hangs:

1. The 5-second limit hits. The client correctly aborts the Commit.
2. The SDK catches this failure and attempts to run Rollback to release the locks.
3. The problem: The library attempted to send the Rollback RPC using the SAME parent context that had just expired. Since the context was already dead, our networking layer refused to send the Rollback out to the server.
4. Because the server never received a Rollback, it kept the locks active for up to 103 seconds (until a backend master timeout cleaned them up).
5. During this time, any new transaction trying to touch those records got blocked, piled up, and failed after 20 seconds with "too much contention" errors.

The Solution

This PR fixes the bug by ensuring the Rollback RPC always goes out, even if the parent context is cancelled or expired:

• Detached Context: We now wrap the rollback context in context.WithoutCancel(t.ctx). This creates a fresh, healthy context that maintains critical tracing metadata but ignores parental cancellation.
• Safe Timeout: We bound the rollback context with an independent 5-second limit so that it cannot block your application indefinitely if the network is completely broken.
• Immediate Lock Release: The Rollback RPC successfully reaches the server, properly releasing locks instantly, enabling subsequent retries to proceed without waiting.