Fix AtomicReference#update livelock when stored value is Float::NAN

The numeric `compare_and_set` wrapper checks `old == old_value` before
delegating to `_compare_and_set`. With `Float::NAN` that check is
always false (`NaN != NaN`), so `#update` retries indefinitely.

Handle expected NaN explicitly so `#update` can terminate.

Author: joshuay03

lib/concurrent-ruby/concurrent/atomic_reference/numeric_cas_wrapper.rb

@@ -9,12 +9,18 @@ module AtomicNumericCompareAndSetWrapper
     # @!macro atomic_reference_method_compare_and_set
     def compare_and_set(old_value, new_value)
       if old_value.kind_of? Numeric
+        # NaN is never == to itself; match it explicitly so #update can terminate.
+        expected_nan = old_value.respond_to?(:nan?) && old_value.nan?
         while true
           old = get
 
           return false unless old.kind_of? Numeric
 
-          return false unless old == old_value
+          if expected_nan
+            return false unless old.respond_to?(:nan?) && old.nan?
+          else
+            return false unless old == old_value
+          end
 
           result = _compare_and_set(old, new_value)
           return result if result

spec/concurrent/atomic/atomic_reference_spec.rb

@@ -1,4 +1,5 @@
 require 'concurrent/atomic/atomic_reference'
+require 'timeout'
 
 RSpec.shared_examples :atomic_reference do
 
@@ -80,6 +81,16 @@
     expect(tries).to eq 2
   end
 
+  specify :test_update_nan do
+    atomic = described_class.new(Float::NAN)
+    tries  = 0
+    result = Timeout.timeout(2) { atomic.update { |_| tries += 1; 0.0 } }
+
+    expect(result).to eq 0.0
+    expect(atomic.value).to eq 0.0
+    expect(tries).to eq 1
+  end
+
   specify :test_numeric_cas do
     atomic = described_class.new(0)
 
@@ -143,6 +154,16 @@
     atomic.set(Complex(1, 2))
     expect(atomic.compare_and_set(Complex(1, 2), 0)).to be_truthy, "CAS failed for #{Complex(1, 2)} => 0"
   end
+
+  specify :test_numeric_cas_nan do
+    atomic = described_class.new(Float::NAN)
+    expect(atomic.compare_and_set(Float::NAN, 0.0)).to be_truthy, "CAS should swap NaN for 0.0"
+    expect(atomic.value).to eq 0.0
+
+    atomic.set(1.0)
+    expect(atomic.compare_and_set(Float::NAN, 0.0)).to be_falsey, "CAS should not swap when current is not NaN"
+    expect(atomic.value).to eq 1.0
+  end
 end
 
 module Concurrent