RUBY-3770 Implement makeTimeoutError semantics in withTransaction

Per DRIVERS-3391 / transactions-convenient-api spec, withTransaction must
propagate a TimeoutError (wrapping the last transient error as .cause) when
the CSOT deadline is exhausted, instead of re-raising the raw error.

Changes to lib/mongo/session.rb:
- Callback raises TransientTransactionError + deadline expired: raise
  TimeoutError in CSOT mode, re-raise original in non-CSOT mode.
- Commit raises UnknownTransactionCommitResult + deadline expired: same.
- Commit raises TransientTransactionError + deadline expired: same.
- Backoff (regular and overload) would exceed deadline: use new
  make_timeout_error_from helper — CSOT wraps last_error with cause,
  non-CSOT raises last_error directly (fixes incorrect TimeoutError
  that was raised in non-CSOT mode before this change).
- Commit overload backoff would exceed deadline: raise TimeoutError in
  CSOT mode, re-raise in non-CSOT mode.
- Add make_timeout_error_from private helper implementing the
  makeTimeoutError(lastError) pseudocode from the spec. Uses an inner
  begin/rescue to wire .cause when called outside a rescue block.

New spec/mongo/session/with_transaction_timeout_spec.rb covers all eight
code paths as unit tests with stubbed time control (no real server needed).

Author: comandeo-mongo

lib/mongo/session.rb

@@ -475,7 +475,7 @@ def with_transaction(options = nil)
           if overload_encountered
             delay = @client.retry_policy.backoff_delay(overload_error_count)
             if backoff_would_exceed_deadline?(deadline, delay)
-              raise Mongo::Error::TimeoutError, 'CSOT timeout expired waiting to retry withTransaction'
+              make_timeout_error_from(last_error)
             end
             unless @client.retry_policy.should_retry_overload?(overload_error_count, delay)
               raise(last_error)
@@ -484,7 +484,7 @@ def with_transaction(options = nil)
           else
             backoff = backoff_seconds_for_retry(transaction_attempt)
             if backoff_would_exceed_deadline?(deadline, backoff)
-              raise Mongo::Error::TimeoutError, 'CSOT timeout expired waiting to retry withTransaction'
+              make_timeout_error_from(last_error)
             end
             sleep(backoff)
           end
@@ -513,7 +513,11 @@ def with_transaction(options = nil)
 
           if deadline_expired?(deadline)
             transaction_in_progress = false
-            raise
+            if @with_transaction_timeout_ms
+              raise Mongo::Error::TimeoutError, 'CSOT timeout expired during withTransaction callback'
+            else
+              raise
+            end
           end
 
           if e.is_a?(Mongo::Error) && e.label?('TransientTransactionError')
@@ -554,7 +558,11 @@ def with_transaction(options = nil)
                 e.is_a?(Error::OperationFailure::Family) && e.max_time_ms_expired?
               then
                 transaction_in_progress = false
-                raise
+                if @with_transaction_timeout_ms && deadline_expired?(deadline)
+                  raise Mongo::Error::TimeoutError, 'CSOT timeout expired during withTransaction commit'
+                else
+                  raise
+                end
               end
 
               if e.label?('SystemOverloadedError')
@@ -569,7 +577,11 @@ def with_transaction(options = nil)
                 delay = @client.retry_policy.backoff_delay(overload_error_count)
                 if backoff_would_exceed_deadline?(deadline, delay)
                   transaction_in_progress = false
-                  raise
+                  if @with_transaction_timeout_ms
+                    raise Mongo::Error::TimeoutError, 'CSOT timeout expired during withTransaction commit'
+                  else
+                    raise
+                  end
                 end
                 unless @client.retry_policy.should_retry_overload?(overload_error_count, delay)
                   transaction_in_progress = false
@@ -591,7 +603,11 @@ def with_transaction(options = nil)
             elsif e.label?('TransientTransactionError')
               if Utils.monotonic_time >= deadline
                 transaction_in_progress = false
-                raise
+                if @with_transaction_timeout_ms
+                  raise Mongo::Error::TimeoutError, 'CSOT timeout expired during withTransaction commit'
+                else
+                  raise
+                end
               end
               last_error = e
               if e.label?('SystemOverloadedError')
@@ -1436,5 +1452,25 @@ def backoff_would_exceed_deadline?(deadline, backoff_seconds)
 
       Utils.monotonic_time + backoff_seconds >= deadline
     end
+
+    # Implements makeTimeoutError(lastError) from the transactions-convenient-api spec.
+    # Called when the withTransaction retry loop cannot continue because backoff would
+    # exceed the deadline.
+    #
+    # - CSOT mode: raises TimeoutError with lastError as Ruby's .cause
+    # - non-CSOT mode: re-raises lastError directly
+    #
+    # Must be called from outside a rescue block; raises unconditionally.
+    def make_timeout_error_from(last_error)
+      if @with_transaction_timeout_ms
+        begin
+          raise last_error
+        rescue
+          raise Mongo::Error::TimeoutError, 'CSOT timeout expired waiting to retry withTransaction'
+        end
+      else
+        raise last_error
+      end
+    end
   end
 end