MONGOID-5972 Clean up review findings in the touch-merge code

Clear the merged-touch flag if the insert update fails, so the
thread-local state does not leak. Fix a stale doc reference, correct
the mechanism described in a spec comment, and hoist the touchable
chain path computation out of the per-key loop.

Author: jamis

lib/mongoid/persistable/creatable.rb

@@ -90,11 +90,12 @@ def conflicting_touch_paths?(operations, touches)
       def rewritten_touch_updates(selector, parent, field, touches)
         rewritten = positionally(selector, { '$set' => touches })['$set']
 
+        chain_paths = parent._touchable_chain_paths(field)
         touches.each_key do |key|
           path = key.to_s
           next if rewritten.key?(path)
 
-          return nil unless parent._touchable_chain_paths(field).include?(path)
+          return nil unless chain_paths.include?(path)
         end
         rewritten
       end
@@ -129,18 +130,24 @@ def insert_as_embedded
 
           deferred_touches = merge_touch_updates(selector, operations)
 
-          _root.collection.find(selector).update_one(
-            positionally(selector, operations),
-            session: _session
-          )
-
-          _root.send(:persist_atomic_operations, '$set' => deferred_touches) if deferred_touches
+          begin
+            _root.collection.find(selector).update_one(
+              positionally(selector, operations),
+              session: _session
+            )
+            _root.send(:persist_atomic_operations, '$set' => deferred_touches) if deferred_touches
+          rescue StandardError
+            # If the insert failed, the after_save callback will not run to
+            # consume and clear the merged-touch flag, so clear it here.
+            Threaded.exit_touch_merged(self)
+            raise
+          end
         end
       end
 
       # Merge the parent chain's pending touch updates into the insert
       # operations when doing so would not produce a conflicting update
-      # (see +conflicting_touch_paths?+ and +misdirected_touch_paths?+).
+      # (see +conflicting_touch_paths?+ and +rewritten_touch_updates+).
       # Either way, marks the touch as merged so the after_save callback
       # does not persist the updates a second time. Returns the touch
       # updates that could not be merged; they are persisted in their own

spec/mongoid/touchable_spec.rb

@@ -1737,8 +1737,9 @@ class TouchableChild
 
       before do
         first_floor
-        # Leave a pending touch on the other floor so the touch updates
-        # conflict with the insert and cannot be merged into it.
+        # Leave a pending touch on the other floor: rewriting it and this
+        # chain's own touch would collapse both onto the same positional
+        # path, so the touch updates cannot be merged into the insert.
         second_floor.updated_at = pending_touch_time
       end