Force Break Undo Groups When Forcing Grouping (#81)

### Description

Forces the undo manager to start a new undo group after calling `startUndoGrouping` or `endUndoGrouping`.

This fixes a case where two groups could accidentally be combined. For instance when dragging text and then dragging it back into the same spot. Previously that operation would result in the following undo grouping:

After first drag:
```
Group 1:
- {0,8} "" // Removed text

Group 2:
- {0, 0} "DragText" // Inserted text
```
After dragging back to the original location:
```
Group 1:
- {0,8} "" // Removed text

Group 2:
- {0, 0} "DragText" // Inserted text
- {0,8} "" // Removed text

Group 3:
- {0, 0} "DragText" // Inserted text
```

When it *should* have looked like the following after the second drag back to the original position.
```
Group 1:
- {0,8} "" // Removed text

Group 2:
- {0, 0} "DragText" // Inserted text

Group 3:
- {0,8} "" // Removed text

Group 4:
- {0, 0} "DragText" // Inserted text
```

### Related Issues

* N/A

### Checklist

<!--- Add things that are not yet implemented above -->

- [x] I read and understood the [contributing guide](https://github.com/CodeEditApp/CodeEdit/blob/main/CONTRIBUTING.md) as well as the [code of conduct](https://github.com/CodeEditApp/CodeEdit/blob/main/CODE_OF_CONDUCT.md)
- [x] The issues this PR addresses are related to each other
- [x] My changes generate no new warnings
- [x] My code builds and runs on my machine
- [x] My changes are all related to the related issue above
- [x] I documented my code

### Screenshots

N/A

Author: thecoolwinter

Sources/CodeEditTextView/Utils/CEUndoManager.swift

@@ -83,6 +83,11 @@ public class CEUndoManager {
 
     private weak var textView: TextView?
     private(set) public var isGrouping: Bool = false
+
+    /// After ``endUndoGrouping`` is called, we'd expect the next mutation to be exclusive no matter what. This
+    /// flag facilitates that, and is set by ``endUndoGrouping``
+    private var shouldBreakNextGroup: Bool = false
+
     /// True when the manager is ignoring mutations.
     private var isDisabled: Bool = false
 
@@ -154,18 +159,19 @@ public class CEUndoManager {
             return
         }
         let newMutation = Mutation(mutation: mutation, inverse: textStorage.inverseMutation(for: mutation))
-        if !undoStack.isEmpty, let lastMutation = undoStack.last?.mutations.last {
-            if isGrouping || shouldContinueGroup(newMutation, lastMutation: lastMutation) {
-                undoStack[undoStack.count - 1].mutations.append(newMutation)
-            } else {
-                undoStack.append(UndoGroup(mutations: [newMutation]))
-            }
+        // We can continue a group if:
+        // - A group exists
+        // - We're not direct to break the current group
+        // - We're forced grouping OR we automagically detect we can group.
+        if !undoStack.isEmpty,
+            let lastMutation = undoStack.last?.mutations.last,
+           !shouldBreakNextGroup,
+           isGrouping || shouldContinueGroup(newMutation, lastMutation: lastMutation) {
+            undoStack[undoStack.count - 1].mutations.append(newMutation)
         } else {
-            undoStack.append(
-                UndoGroup(mutations: [newMutation])
-            )
+            undoStack.append(UndoGroup(mutations: [newMutation]))
+            shouldBreakNextGroup = false
         }
-
         redoStack.removeAll()
     }
 
@@ -178,6 +184,8 @@ public class CEUndoManager {
             return
         }
         isGrouping = true
+        // This is a new undo group, break for it.
+        shouldBreakNextGroup = true
     }
 
     /// Stops grouping all incoming mutations.
@@ -187,6 +195,8 @@ public class CEUndoManager {
             return
         }
         isGrouping = false
+        // We just ended a group, do not allow the next mutation to be added to the group we just made.
+        shouldBreakNextGroup = true
     }
 
     /// Determines whether or not two mutations should be grouped.