Optimize String visitor by hand

Followup: rails#54504
Followup: rails#54491

The existing inheritence based visitor cause a lot of extra
method calls and rely on `send` a lot, defeating method caches.

Since that visitor in particular is part of the hot path of finding
a route for the incomming request, it's worth optimizing it specifically.

And in the end, I could argue it's much easier to grok than the previous
implementation.

Same benchmark as: rails#54491 (comment)

```
== index ==
ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +YJIT +PRISM [arm64-darwin23]
Warming up --------------------------------------
               after    40.563k i/100ms
Calculating -------------------------------------
               after    405.756k (± 2.5%) i/s    (2.46 μs/i) -      2.028M in   5.001706s

Comparison:
              before:   361017.1 i/s
               after:   405756.2 i/s - 1.12x  faster

== show ==
ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +YJIT +PRISM [arm64-darwin23]
Warming up --------------------------------------
               after    31.235k i/100ms
Calculating -------------------------------------
               after    316.240k (± 1.2%) i/s    (3.16 μs/i) -      1.593M in   5.038025s

Comparison:
              before:   274268.3 i/s
               after:   316240.2 i/s - 1.15x  faster

== show_nested ==
ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +YJIT +PRISM [arm64-darwin23]
Warming up --------------------------------------
               after    29.238k i/100ms
Calculating -------------------------------------
               after    286.828k (± 1.4%) i/s    (3.49 μs/i) -      1.462M in   5.097862s

Comparison:
              before:   246428.3 i/s
               after:   286828.0 i/s - 1.16x  faster
```

Author: byroot

actionpack/lib/action_dispatch/journey/nodes/node.rb

@@ -81,7 +81,7 @@ def each(&block)
         end
 
         def to_s
-          Visitors::String::INSTANCE.accept(self, "")
+          Visitors::String::INSTANCE.accept(self, "".dup)
         end
 
         def to_dot

actionpack/lib/action_dispatch/journey/visitors.rb

@@ -128,8 +128,8 @@ def visit_SLASH(n, seed);   terminal(n, seed); end
         def visit_DOT(n, seed);     terminal(n, seed); end
 
         instance_methods(false).each do |pim|
-          next unless pim =~ /^visit_(.*)$/
-          DISPATCH_CACHE[$1.to_sym] = pim
+          next unless pim.start_with?("visit_")
+          DISPATCH_CACHE[pim.name.delete_prefix("visit_").to_sym] = pim
         end
       end
 
@@ -167,32 +167,64 @@ def visit(node, block)
         INSTANCE = new
       end
 
-      class String < FunctionalVisitor # :nodoc:
-        private
-          def binary(node, seed)
-            visit(node.right, visit(node.left, seed))
-          end
-
-          def nary(node, seed)
+      class String # :nodoc:
+        def accept(node, seed)
+          case node.type
+          when :DOT
+            seed << node.left
+          when :LITERAL
+            seed << node.left
+          when :SYMBOL
+            seed << node.left
+          when :SLASH
+            seed << node.left
+          when :CAT
+            accept(node.right, accept(node.left, seed))
+          when :STAR
+            accept(node.left, seed)
+          when :OR
             last_child = node.children.last
-            node.children.inject(seed) { |s, c|
-              string = visit(c, s)
-              string << "|" unless last_child == c
-              string
-            }
-          end
-
-          def terminal(node, seed)
-            seed + node.left
-          end
-
-          def visit_GROUP(node, seed)
-            visit(node.left, seed.dup << "(") << ")"
+            node.children.each do |c|
+              accept(c, seed)
+              seed << "|" unless last_child == c
+            end
+            seed
+          when :GROUP
+            accept(node.left, seed << "(") << ")"
+          else
+            raise "Unknown node type: #{node.type}"
           end
+        end
 
-          INSTANCE = new
+        INSTANCE = new
       end
 
+      # class String < FunctionalVisitor # :nodoc:
+      #   private
+      #     def binary(node, seed)
+      #       visit(node.right, visit(node.left, seed))
+      #     end
+      #
+      #     def nary(node, seed)
+      #       last_child = node.children.last
+      #       node.children.inject(seed) { |s, c|
+      #         string = visit(c, s)
+      #         string << "|" unless last_child == c
+      #         string
+      #       }
+      #     end
+      #
+      #     def terminal(node, seed)
+      #       seed + node.left
+      #     end
+      #
+      #     def visit_GROUP(node, seed)
+      #       visit(node.left, seed.dup << "(") << ")"
+      #     end
+      #
+      #     INSTANCE = new
+      # end
+
       class Dot < FunctionalVisitor # :nodoc:
         def initialize
           @nodes = []