A number of points:

1. Your coerce method should return self as the second argument, e.g.

   def coerce(other)
      [<coercion-of-other-value-here>, self]
   end

2. Given the incorrect order in yours, the <=> method is called on the instance of AS::TWZ. This calls <=> on the instance of Time and that triggers this block of code:
   

   rails/activesupport/lib/active_support/core_ext/time/calculations.rb

   Lines 329 to 343 in a993c27

   	def compare_with_coercion(other)
   	# we're avoiding Time#to_datetime and Time#to_time because they're expensive
   	if other.class == Time
   	compare_without_coercion(other)
   	elsif other.is_a?(Time)
   	# also avoid ActiveSupport::TimeWithZone#to_time before Rails 8.0
   	if other.respond_to?(:comparable_time)
   	compare_without_coercion(other.comparable_time)
   	else
   	compare_without_coercion(other.to_time)
   	end
   	else
   	to_datetime <=> other
   	end
   	end

   The other in this block is your instance of CustomDateTime and since it is neither a Time or Time subclass it hits the else block that converts the AS::TWZ to a DateTime. This DateTime instance receives <=> which calls coerce on your CustomDateTime and the order flips back and your CustomDateTime receives the <=> and returns 0.

3. Your spec setup seems wrong - I couldn't drop a binding.irb in the block. This version seems to work as you expect it to:

   expect(custom_date_time).to receive(:<=>).and_wrap_original do |original_method, other|
     expect(other).not_to be_an(ActiveSupport::TimeWithZone)
     original_method.call(other)
   end

   As you can see from the explanation above the <=> gets called on CustomDateTime after the conversion of the original value to DateTime which is why the spec passes.

4. The Active Support date/time methods don't support coerce in general because numeric operations beyond a simple <=> don't make sense, e.g. this works as expected:

   Time.current + 2.days

   But this fails with a TypeError:

   2.days + Time.current

   However, numeric operations with ActiveSupport::Duration do make sense and I suggest checking out that code to get a clearer understanding of how coerce works.

Thanks for the reply @pixeltrix. Didn't get a chance to look into this last week. Here's what I noticed about your suggestions.

1. Swapping the elements in the array (as you suggested) throws the program into an infinite loop. Which is correct because coerce is supposed to return an Array where the first element is the one on whom you expect the <=> to be forwarded to. In my case, that'd be self since I'm trying to tell Ruby that I'll handle the coercion instead of letting ActiveSupport::TimeWithZone do it for me.
2. This is helpful in knowing how things work. Thank you so much for pointing me to this bit of code.
3. Yeah you're right. I've updated the specs to what you suggested. Also inverted the expect condition so that the expected and actual behaviour are better understood. Sorry for the confusion earlier.