Track parent key as string in ParameterFilter

This avoids allocating an array each time `ParameterFilter#filter` is
called, and avoids a few redundant operations when building up the
full key.  This yields a small but reproducible performance increase:

**Benchmark script**

  ```ruby
  # frozen_string_literal: true
  require "benchmark/ips"
  require "benchmark/memory"
  require "active_support"
  require "active_support/parameter_filter"

  ootb = [:passw, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn]
  mixed = [:passw, "secret", /token/, :crypt, "salt", /certificate/, "user.otp", /user\.ssn/, proc {}]

  params = {
    "user" => {
      "name" => :name,
      "email" => :email,
      "password" => :password,
      "ssn" => :ssn,
      "locations" => [
        { "city" => :city, "country" => :country },
        { "city" => :city, "country" => :country },
      ],
    }
  }

  Benchmark.ips do |x|
    x.report("ootb") do
      ActiveSupport::ParameterFilter.new(ootb).filter(params)
    end

    x.report("mixed") do
      ActiveSupport::ParameterFilter.new(mixed).filter(params)
    end
  end
  ```

**Before**

  ```
  Warming up --------------------------------------
                  ootb     2.003k i/100ms
                 mixed     1.362k i/100ms
  Calculating -------------------------------------
                  ootb     19.975k (± 0.9%) i/s -    100.150k in   5.014277s
                 mixed     13.627k (± 0.9%) i/s -     69.462k in   5.097741s
  ```

**After**

  ```
  Warming up --------------------------------------
                  ootb     2.032k i/100ms
                 mixed     1.521k i/100ms
  Calculating -------------------------------------
                  ootb     20.315k (± 1.3%) i/s -    101.600k in   5.001939s
                 mixed     15.142k (± 1.2%) i/s -     76.050k in   5.023077s
  ```

Author: jonathanhefner

activesupport/lib/active_support/parameter_filter.rb

@@ -100,37 +100,35 @@ def initialize(regexps, deep_regexps, blocks, mask:)
         @mask = mask
       end
 
-      def call(params, parents = [], original_params = params)
+      def call(params, full_parent_key = nil, original_params = params)
         filtered_params = params.class.new
 
         params.each do |key, value|
-          filtered_params[key] = value_for_key(key, value, parents, original_params)
+          filtered_params[key] = value_for_key(key, value, full_parent_key, original_params)
         end
 
         filtered_params
       end
 
-      def value_for_key(key, value, parents = [], original_params = nil)
-        parents.push(key) if deep_regexps
+      def value_for_key(key, value, full_parent_key = nil, original_params = nil)
+        if deep_regexps
+          full_key = full_parent_key ? "#{full_parent_key}.#{key}" : key.to_s
+        end
+
         if regexps.any? { |r| r.match?(key.to_s) }
           value = @mask
-        elsif deep_regexps && (joined = parents.join(".")) && deep_regexps.any? { |r| r.match?(joined) }
+        elsif deep_regexps&.any? { |r| r.match?(full_key) }
           value = @mask
         elsif value.is_a?(Hash)
-          value = call(value, parents, original_params)
+          value = call(value, full_key, original_params)
         elsif value.is_a?(Array)
-          # If we don't pop the current parent it will be duplicated as we
-          # process each array value.
-          parents.pop if deep_regexps
-          value = value.map { |v| value_for_key(key, v, parents, original_params) }
-          # Restore the parent stack after processing the array.
-          parents.push(key) if deep_regexps
+          value = value.map { |v| value_for_key(key, v, full_parent_key, original_params) }
         elsif blocks.any?
           key = key.dup if key.duplicable?
           value = value.dup if value.duplicable?
           blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
         end
-        parents.pop if deep_regexps
+
         value
       end
     end