Check happy path first when comparing gem version:

- During resolution, Gem::Version are compared against each other.
  Since comparing versions is a very hot path we can micro optimize
  it to check the happy path first.

  The speed gain on the overall resolution isn't significant but the
  ips gain is quite substantial. The diff chunk is small so I figure
  it's worth it anyway.

  ```ruby
  a = Gem::Version.new("5.3.1")
  b = Gem::Version.new("5.3.1")

  Benchmark.ips do |x|
    x.report("equal regular:") { a <=> c }
    x.report("equal optimized:") { a <=> c }
    x.hold!("equal_temp_results")
    x.compare!(order: :baseline)
  end
  ```

  ```
  Warming up --------------------------------------
      equal optimized:     1.268M i/100ms
  Calculating -------------------------------------
      equal optimized:     12.738M (± 1.5%) i/s   (78.50 ns/i) -     64.680M in   5.078754s

  Comparison:
        equal regular::  9866605.0 i/s
      equal optimized:: 12738310.3 i/s - 1.29x  faster
  ```

ruby 3.4.8 (2025-12-17 revision 995b59f666) +PRISM [arm64-darwin25]

Author: Edouard-chin

lib/rubygems/version.rb

@@ -345,60 +345,58 @@ def approximate_recommendation
   # other types may raise an exception.
 
   def <=>(other)
-    if String === other
-      return unless self.class.correct?(other)
-      return self <=> self.class.new(other)
-    end
-
-    return unless Gem::Version === other
-
-    # Fast path for comparison when available.
-    if @sort_key && other.sort_key
-      return @sort_key <=> other.sort_key
-    end
-
-    return 0 if @version == other.version || canonical_segments == other.canonical_segments
+    if Gem::Version === other
+      # Fast path for comparison when available.
+      if @sort_key && other.sort_key
+        return @sort_key <=> other.sort_key
+      end
 
-    lhsegments = canonical_segments
-    rhsegments = other.canonical_segments
+      return 0 if @version == other.version || canonical_segments == other.canonical_segments
 
-    lhsize = lhsegments.size
-    rhsize = rhsegments.size
-    limit  = (lhsize > rhsize ? rhsize : lhsize)
+      lhsegments = canonical_segments
+      rhsegments = other.canonical_segments
 
-    i = 0
+      lhsize = lhsegments.size
+      rhsize = rhsegments.size
+      limit  = (lhsize > rhsize ? rhsize : lhsize)
 
-    while i < limit
-      lhs = lhsegments[i]
-      rhs = rhsegments[i]
-      i += 1
+      i = 0
 
-      next      if lhs == rhs
-      return -1 if String  === lhs && Numeric === rhs
-      return  1 if Numeric === lhs && String  === rhs
+      while i < limit
+        lhs = lhsegments[i]
+        rhs = rhsegments[i]
+        i += 1
 
-      return lhs <=> rhs
-    end
+        next      if lhs == rhs
+        return -1 if String  === lhs && Numeric === rhs
+        return  1 if Numeric === lhs && String  === rhs
 
-    lhs = lhsegments[i]
+        return lhs <=> rhs
+      end
 
-    if lhs.nil?
-      rhs = rhsegments[i]
+      lhs = lhsegments[i]
 
-      while i < rhsize
-        return 1 if String === rhs
-        return -1 unless rhs.zero?
-        rhs = rhsegments[i += 1]
-      end
-    else
-      while i < lhsize
-        return -1 if String === lhs
-        return 1 unless lhs.zero?
-        lhs = lhsegments[i += 1]
+      if lhs.nil?
+        rhs = rhsegments[i]
+
+        while i < rhsize
+          return 1 if String === rhs
+          return -1 unless rhs.zero?
+          rhs = rhsegments[i += 1]
+        end
+      else
+        while i < lhsize
+          return -1 if String === lhs
+          return 1 unless lhs.zero?
+          lhs = lhsegments[i += 1]
+        end
       end
-    end
 
-    0
+      0
+    elsif String === other
+      return unless self.class.correct?(other)
+      self <=> self.class.new(other)
+    end
   end
 
   # remove trailing zeros segments before first letter or at the end of the version