Add parallel step groups to CI runner

Steps can be grouped and run in parallel:

```ruby
group "Checks", parallel: 3 do
  step "Style: Ruby", "bin/rubocop"
  step "Security: Brakeman", "bin/brakeman --quiet"
  step "Security: Gem audit", "bin/bundler-audit"
end
```

`parallel` defaults to 1, which runs steps sequentially.

Parallel steps capture output via PTY (or Open3 as fallback) to prevent
interleaving, with a live progress line showing running steps.

Groups can be nested, but only the outer group can run in parallel. This
allows dependent steps to run sequentially within a parallel group:

```ruby
group "Checks", parallel: 2 do
  group "Tests" do
    step "Tests: Rails", "bin/rails test"
    step "Tests: Seeds", "env RAILS_ENV=test bin/rails db:seed:replant"
  end

  step "Style: Ruby", "bin/rubocop"
  step "Security: Brakeman", "bin/brakeman --quiet"
  step "Security: Gem audit", "bin/bundler-audit"
end
```

Author: djmb

activesupport/CHANGELOG.md

@@ -1,3 +1,28 @@
+*   Add `group` method to `ActiveSupport::ContinuousIntegration` for parallel step execution.
+
+    Groups collect steps and run them concurrently using a thread pool, reducing CI times
+    by running independent checks (tests, linting, security audits) in parallel. Sub-groups
+    run sequentially within a single parallel slot.
+
+    ```ruby
+    CI.run do
+      step "Setup", "bin/setup --skip-server"
+
+      group "Checks", parallel: 3 do
+        step "Style: Ruby", "bin/rubocop"
+        step "Security: Brakeman", "bin/brakeman --quiet"
+        step "Security: Gem audit", "bin/bundler-audit"
+
+        group "Tests" do
+          step "Tests: Rails", "bin/rails test"
+          step "Tests: Seeds", "env RAILS_ENV=test bin/rails db:seed:replant"
+        end
+      end
+    end
+    ```
+
+    *Donal McBreen*
+
 *   Fix inflections to better handle overlapping acronyms.
 
     ```ruby

activesupport/lib/active_support/continuous_integration.rb

@@ -27,7 +27,8 @@ class ContinuousIntegration
       title: "\033[1;35m",    # Purple
       subtitle: "\033[1;90m", # Medium Gray
       error: "\033[1;31m",    # Red
-      success: "\033[1;32m"   # Green
+      success: "\033[1;32m",  # Green
+      progress: "\033[1;36m"  # Cyan
     }
 
     attr_reader :results
@@ -55,12 +56,15 @@ class ContinuousIntegration
     #     end
     #   end
     def self.run(title = "Continuous Integration", subtitle = "Running tests, style checks, and security audits", &block)
-      new.tap do |ci|
-        ENV["CI"] = "true"
-        ci.heading title, subtitle, padding: false
-        ci.report(title, &block)
-        abort unless ci.success?
-      end
+      ENV["CI"] = "true"
+      new.run(title, subtitle, &block)
+    end
+
+    def run(title, subtitle, &block)
+      heading title, subtitle, padding: false
+      success, seconds = execute(title, &block)
+      result_line(title, success, seconds)
+      abort unless success?
     end
 
     def initialize
@@ -75,8 +79,41 @@ def initialize
     #   step "Setup", "bin/setup"
     #   step "Single test", "bin/rails", "test", "--name", "test_that_is_one"
     def step(title, *command)
-      heading title, command.join(" "), type: :title
-      report(title) { results << [ system(*command), title ] }
+      Signal.trap("INT") { abort colorize("\n❌ #{title} interrupted", :error) }
+      report_step(title, command) do
+        started = Time.now.to_f
+        [system(*command), Time.now.to_f - started]
+      end
+      abort if failing_fast?
+    end
+
+    # Declare a group of steps that can be run in parallel. Steps within the group are collected first,
+    # then executed either concurrently (when +parallel+ > 1) or sequentially (when +parallel+ is 1).
+    #
+    # When running in parallel, each step's output is captured to avoid interleaving, and a progress
+    # display shows which steps are currently running.
+    #
+    # Sub-groups within a parallel group occupy a single parallel slot and run their steps sequentially.
+    #
+    # Examples:
+    #
+    #   group "Checks", parallel: 3 do
+    #     step "Style: Ruby", "bin/rubocop"
+    #     step "Security: Brakeman", "bin/brakeman --quiet"
+    #     step "Security: Gem audit", "bin/bundler-audit"
+    #   end
+    #
+    #   group "Tests" do
+    #     step "Unit tests", "bin/rails test"
+    #     step "System tests", "bin/rails test:system"
+    #   end
+    def group(name, parallel: 1, &block)
+      if parallel <= 1
+        instance_eval(&block)
+      else
+        Group.new(self, name, parallel: parallel, &block).run
+      end
+      abort if failing_fast?
     end
 
     # Returns true if all steps were successful.
@@ -95,8 +132,6 @@ def failure(title, subtitle = nil)
     #
     #   heading "Smoke Testing", "End-to-end tests verifying key functionality", padding: false
     #   heading "Skipping video encoding tests", "Install FFmpeg to run these tests", type: :error
-    #
-    # See ActiveSupport::ContinuousIntegration::COLORS for a complete list of options.
     def heading(heading, subtitle = nil, type: :banner, padding: true)
       echo "#{padding ? "\n\n" : ""}#{heading}", type: type
       echo "#{subtitle}#{padding ? "\n" : ""}", type: :subtitle if subtitle
@@ -108,65 +143,83 @@ def heading(heading, subtitle = nil, type: :banner, padding: true)
     #
     #   echo "This is going to be green!", type: :success
     #   echo "This is going to be red!", type: :error
-    #
-    # See ActiveSupport::ContinuousIntegration::COLORS for a complete list of options.
     def echo(text, type:)
       puts colorize(text, type)
     end
 
     # :nodoc:
-    def report(title, &block)
-      Signal.trap("INT") { abort colorize("\n❌ #{title} interrupted", :error) }
-
-      ci = self.class.new
-      elapsed = timing { ci.instance_eval(&block) }
-
-      if ci.success?
-        echo "\n✅ #{title} passed in #{elapsed}", type: :success
-      else
-        echo "\n❌ #{title} failed in #{elapsed}", type: :error
-
-        abort if ci.fail_fast?
-
-        if ci.multiple_results?
-          ci.failures.each do |success, title|
-            unless success
-              echo "   ↳ #{title} failed", type: :error
-            end
-          end
-        end
-      end
-
-      results.concat ci.results
-    ensure
-      Signal.trap("INT", "-")
+    def report_step(title, command)
+      heading title, command.join(" "), type: :title
+      success, seconds = yield
+      result_line(title, success, seconds)
+      results << [success, title]
+      success
     end
 
     # :nodoc:
-    def failures
-      results.reject(&:first)
+    def colorize(text, type)
+      "#{COLORS.fetch(type)}#{text}\033[0m"
     end
 
     # :nodoc:
-    def multiple_results?
-      results.size > 1
+    def fail_fast?
+      ARGV.include?("-f") || ARGV.include?("--fail-fast")
     end
 
     # :nodoc:
-    def fail_fast?
-      ARGV.include?("-f") || ARGV.include?("--fail-fast")
+    def failing_fast?
+      fail_fast? && failures.any?
     end
 
     private
+      def failures
+        results.reject(&:first)
+      end
+
+      def multiple_results?
+        results.size > 1
+      end
+
+      def execute(title, &block)
+        Signal.trap("INT") { abort colorize("\n❌ #{title} interrupted", :error) }
+
+        seconds = timing { instance_eval(&block) }
+
+        unless success?
+          if multiple_results?
+            failures.each do |success, title|
+              unless success
+                echo "   ↳ #{title} failed", type: :error
+              end
+            end
+          end
+        end
+
+        [success?, seconds]
+      ensure
+        Signal.trap("INT", "-")
+      end
+
+      def result_line(title, success, seconds)
+        elapsed = format_elapsed(seconds)
+        if success
+          echo "\n✅ #{title} passed in #{elapsed}", type: :success
+        else
+          echo "\n❌ #{title} failed in #{elapsed}", type: :error
+        end
+      end
+
+      def format_elapsed(seconds)
+        min, sec = seconds.divmod(60)
+        "#{"#{min.to_i}m" if min > 0}%.2fs" % sec
+      end
+
       def timing
         started_at = Time.now.to_f
         yield
-        min, sec = (Time.now.to_f - started_at).divmod(60)
-        "#{"#{min}m" if min > 0}%.2fs" % sec
-      end
-
-      def colorize(text, type)
-        "#{COLORS.fetch(type)}#{text}\033[0m"
+        Time.now.to_f - started_at
       end
   end
 end
+
+require_relative "continuous_integration/group"