Reuse decls in resolve_type_names when no type names change

`resolve_type_names` previously rebuilt every declaration, member, and
type even when type name resolution did not change anything. The first
resolve must produce absolutized type names, so its cost is
unavoidable; but the second and later resolves were re-allocating
identical structures for no benefit, pressuring GC heavily.

This change makes every `map_type_name` / `map_type` / `resolve_*`
helper return its receiver when each child maps back to a value
`equal?` to the original. Combined with the existing flyweight
behavior of `TypeName` and `Namespace`, declarations whose type names
were already absolute are now reused verbatim across resolves.

The first resolve is therefore unchanged in both wall time and
allocations. The numbers below compare the second-and-later resolves
only, measured on conference-app (kaigionrails/conference-app):

  - allocated per resolve:     20.60 MB / 387,664 objects
                            ->  3.52 MB /  64,293 objects   (-83%)
  - retained over 10 resolves: 18.36 MB / 346,343 objects
                            ->  1.25 MB /  22,973 objects   (-93%)
  - resolve wall time, p99:   112.7 ms  ->  98.3 ms         (-12.8%)
  - GC major / 50 resolves:    4        ->  1               (-75%)

Single-shot CLI usage (`rbs list` etc.) calls resolve_type_names only
once, so it sees no change. Long-running clients such as Steep that
re-resolve repeatedly are the primary beneficiaries.

Author: tk0miya

lib/rbs.rb

@@ -102,5 +102,51 @@ def print_warning()
         logger.warn { message }
       end
     end
+
+    # Internal helper for `map_type_name` / `map_type` / `resolve_*` paths
+    # in this gem. The given block is invoked for every element. Returns
+    # the input array unchanged (the same object) when every mapped result
+    # is `equal?` to its source; otherwise returns a fresh array with the
+    # changed elements substituted in. Callers detect a no-op by comparing
+    # the return value with the input via `equal?`, which avoids
+    # allocating a `[mapped, changed]` tuple on every invocation.
+    def map_if_changed(array, &)
+      return array if array.empty?
+
+      result = array
+      changed = false
+      array.each_with_index do |element, i|
+        new_element = yield(element)
+        next if new_element.equal?(element)
+
+        unless changed
+          result = array.dup
+          changed = true
+        end
+        result[i] = new_element
+      end
+      result
+    end
+
+    # Hash counterpart of `map_if_changed`: transforms values through the
+    # block and returns the receiver unchanged when every value identity
+    # is preserved.
+    def transform_values_if_changed(hash, &)
+      return hash if hash.empty?
+
+      result = hash
+      changed = false
+      hash.each do |key, value|
+        new_value = yield(value)
+        next if new_value.equal?(value)
+
+        unless changed
+          result = hash.dup
+          changed = true
+        end
+        result[key] = new_value
+      end
+      result
+    end
   end
 end

lib/rbs/ast/type_param.rb

@@ -67,25 +67,23 @@ def to_json(state = JSON::State.new)
       end
 
       def map_type(&block)
-        if b = upper_bound_type
-          _upper_bound_type = yield(b)
-        end
-
-        if b = lower_bound_type
-          _lower_bound_type = yield(b)
-        end
+        new_upper_bound_type = upper_bound_type ? yield(upper_bound_type) : nil
+        new_lower_bound_type = lower_bound_type ? yield(lower_bound_type) : nil
+        new_default_type = default_type ? yield(default_type) : nil
 
-        if dt = default_type
-          _default_type = yield(dt)
+        if new_upper_bound_type.equal?(upper_bound_type) &&
+           new_lower_bound_type.equal?(lower_bound_type) &&
+           new_default_type.equal?(default_type)
+          return self
         end
 
         TypeParam.new(
           name: name,
           variance: variance,
-          upper_bound: _upper_bound_type,
-          lower_bound: _lower_bound_type,
+          upper_bound: new_upper_bound_type,
+          lower_bound: new_lower_bound_type,
           location: location,
-          default_type: _default_type
+          default_type: new_default_type
         ).unchecked!(unchecked?)
       end