Simplify stdparam state to reduce retained hashes

Previously, the stdparam_state would look somthing like:

```
{
  13 => { /\A(?-mix:[^.\/?]+)\Z/ => 24 },
  14 => { /\A(?-mix:[^.\/?]+)\Z/ => 25 },
  15 => { /\A(?-mix:[^.\/?]+)\Z/ => 26 },
  16 => { /\A(?-mix:[^.\/?]+)\Z/ => 27 },
  17 => { /\A(?-mix:[^.\/?]+)\Z/ => 28 },
  18 => { /\A(?-mix:[^.\/?]+)\Z/ => 29 },
  19 => { /\A(?-mix:[^.\/?]+)\Z/ => 30 },
  20 => { /\A(?-mix:[^.\/?]+)\Z/ => 31 },
  ...
}
```

Every single value is a hash with DEFAULT_EXP_ANCHORED as the only key
and a state as the only value. Additionally, because these values are
hashes, the Transition Table used `#each` to iterate over them even
though the iteration ignores the key, DEFAULT_EXP_ANCHORED (since the
`match?` is cached outside the loop), and the hash will only ever
contain a single entry.

This commit refactors the `stdparam_state` to be a simple hash mapping
`from` to `to` values:

```
{
  13 => 24,
  14 => 25,
  15 => 26,
  16 => 27,
  17 => 28,
  18 => 29,
  19 => 30,
  20 => 31,
  ...
}
```

In a large application this can save thousands of retained hashes
(concretely, in jeremyevans/r10k's `rails_4_10.rb` benchmark this saves
21111 hashes).

Author: skipkayhil

actionpack/lib/action_dispatch/journey/gtg/transition_table.rb

@@ -59,8 +59,8 @@ def move(t, full_string, start_index, end_index)
             if previous_start.nil?
               # In the simple case of a "default" param regex do this fast-path and add all
               # next states.
-              if token_matches_default_component && states = @stdparam_states[s]
-                states.each { |re, v| next_states << [v, nil].freeze if !v.nil? }
+              if token_matches_default_component && std_state = @stdparam_states[s]
+                next_states << [std_state, nil].freeze
               end
 
               # When we have a literal string, we can just pull the next state
@@ -163,54 +163,40 @@ def visualizer(paths, title = "FSM")
         end
 
         def []=(from, to, sym)
-          to_mappings = states_hash_for(sym)[from] ||= {}
           case sym
+          when String, Symbol
+            to_mapping = @string_states[from] ||= {}
+            # account for symbols in the constraints the same as strings
+            to_mapping[sym.to_s] = to
           when Regexp
-            # we must match the whole string to a token boundary
             if sym == DEFAULT_EXP
-              sym = DEFAULT_EXP_ANCHORED
+              @stdparam_states[from] = to
             else
-              sym = /\A#{sym}\Z/
+              to_mapping = @regexp_states[from] ||= {}
+              # we must match the whole string to a token boundary
+              to_mapping[/\A#{sym}\Z/] = to
             end
-          when Symbol
-            # account for symbols in the constraints the same as strings
-            sym = sym.to_s
+          else
+            raise ArgumentError, "unknown symbol: %s" % sym.class
           end
-          to_mappings[sym] = to
         end
 
         def states
           ss = @string_states.keys + @string_states.values.flat_map(&:values)
-          ps = @stdparam_states.keys + @stdparam_states.values.flat_map(&:values)
+          ps = @stdparam_states.keys + @stdparam_states.values
           rs = @regexp_states.keys + @regexp_states.values.flat_map(&:values)
           (ss + ps + rs).uniq
         end
 
         def transitions
           @string_states.flat_map { |from, hash|
             hash.map { |s, to| [from, s, to] }
-          } + @stdparam_states.flat_map { |from, hash|
-            hash.map { |s, to| [from, s, to] }
+          } + @stdparam_states.map { |from, to|
+            [from, DEFAULT_EXP_ANCHORED, to]
           } + @regexp_states.flat_map { |from, hash|
             hash.map { |s, to| [from, s, to] }
           }
         end
-
-        private
-          def states_hash_for(sym)
-            case sym
-            when String, Symbol
-              @string_states
-            when Regexp
-              if sym == DEFAULT_EXP
-                @stdparam_states
-              else
-                @regexp_states
-              end
-            else
-              raise ArgumentError, "unknown symbol: %s" % sym.class
-            end
-          end
       end
     end
   end

actionpack/lib/action_dispatch/journey/visualizer/fsm.js

@@ -105,12 +105,10 @@ function match(input) {
         }
 
         if(stdparam_states[state] && default_re.test(token)) {
-          for(var key in stdparam_states[state]) {
-            var new_state = stdparam_states[state][key];
-            highlight_edge(state, new_state);
-            highlight_state(new_state);
-            new_states.push([new_state, null]);
-          }
+          var new_state = stdparam_states[state];
+          highlight_edge(state, new_state);
+          highlight_state(new_state);
+          new_states.push([new_state, null]);
         }
       }