Narrow other via self.class == other.class in flow-sensitive typing

[apiology]

Claude: This PR was written by Claude Code on behalf of @apiology.

Problem: A common #==/#eql? idiom checks self.class == other.class before comparing fields, but flow-sensitive typing does not narrow other from that check, so every field comparison after it fails at strong.

class UniqueType
  def eql? other
    self.class == other.class &&
      # Unresolved call to name on Object
      @name == other.name
  end
end

other stays declared Object even though the guard proves it shares self's runtime class.

Solution: self.class == other.class guarantees other's runtime class equals self's, and that runtime class is always a subtype of the enclosing method's declared instance type — so narrowing other to that declared type is a sound upper bound, the same tradeoff #process_isa documents for is_a?. FlowSensitiveTyping never received the enclosing closure, so it could not resolve self's type; this threads it through and adds #process_class_eq, covering both an && chain and a return false unless guard. Skipped for class methods, whose self.class is always ::Class.

Clears all 9 @sg-ignore markers on this repo's own #==/#eql? methods, confirmed by a byte-identical full-workspace typecheck problem set once the markers are removed.