Disable calling rules when they return .skipChildren.

Add a map `shouldSkipChildren` that tracks which rules are currently skipping children.
Install handlers in visitPost for each rule that determine when we should start visiting children again (when we leave the node we're skipping).

Author: thunderseethe

Sources/SwiftFormat/Core/LintPipeline.swift

@@ -29,8 +29,13 @@ extension LintPipeline {
     _ visitor: (Rule) -> (Node) -> SyntaxVisitorContinueKind, for node: Node
   ) {
     guard context.isRuleEnabled(Rule.self, node: Syntax(node)) else { return }
+    let ruleId = ObjectIdentifier(Rule.self)
+    guard self.shouldSkipChildren[ruleId] == nil else { return }
     let rule = self.rule(Rule.self)
-    _ = visitor(rule)(node)
+    let continueKind = visitor(rule)(node)
+    if case .skipChildren = continueKind {
+      self.shouldSkipChildren[ruleId] = node
+    }
   }
 
   /// Calls the `visit` method of a rule for the given node if that rule is enabled for the node.
@@ -50,10 +55,27 @@ extension LintPipeline {
     // cannot currently be expressed as constraints without duplicating this function for each of
     // them individually.
     guard context.isRuleEnabled(Rule.self, node: Syntax(node)) else { return }
+    guard self.shouldSkipChildren[ObjectIdentifier(Rule.self)] == nil else { return }
     let rule = self.rule(Rule.self)
     _ = visitor(rule)(node)
   }
 
+  /// Cleans up any state associated with `rule` when we leave syntax node `node`
+  ///
+  /// - Parameters:
+  ///   - rule: The type of the syntax rule we're cleaning up.
+  ///   - node: The syntax node htat our traversal has left.
+  func onVisitPost<R: Rule, Node: SyntaxProtocol>(
+    rule: R.Type, for node: Node
+  ) {
+    let rule = ObjectIdentifier(rule)
+    if case .some(let skipNode) = self.shouldSkipChildren[rule] {
+      if node.id == skipNode.id {
+        self.shouldSkipChildren.removeValue(forKey: rule)
+      }
+    }
+  }
+
   /// Retrieves an instance of a lint or format rule based on its type.
   ///
   /// There is at most 1 instance of each rule allocated per `LintPipeline`. This method will