How can mainstream OO languages support strong binary operations by classes?
I will attempt an answer, though, the discussion in comments with @yuval-filmus seems to be going in the right way.

Let's recap: The book discusses ADTs against objects in their strictest sense.

ADTs are entirely public about their unique representation. Belonging in the ADT means satisfying said representation, and so binary methods can rightfully assume that both operands have that exact representation.

Objects are entirely opaque about their non-unique representation. Belonging in the object type means satisfying its interface, with no guarantees as to how this is achieved internally, and so binary methods may only assume that the two objects can respond to the same set of messages, but are quite possibly implemented entirely differently.

Even if the interface has a getter getFoo, that is no guarantee that the object has a foo field that you could poke at directly. Maybe some mock object is faking it with a method that returns a constant Foo. All you know as a client is that it supports a getFoo call.



Where the class-based object approach differs from the pure object approach is that the knowledge of the type of an object (the class it belongs to) gives you some guarantees about the structure of the object, and so, allows you to partially break the abstraction barrier.  Because all objects of a class must have been built with, at least, a call to the constructor of that class, you can guarantee the presence of some fields (initialized during that constructor), and so the language lets you access those directly, foregoing the mandatory message-passing of the pure object style.

This is a strength and a weakness:


because you have access to the concrete representation, you might be able to implement operations more efficiently,
but because you ask for a member of the class, a "mock" implementation is no longer a valid object for this operation: if you want to allow such an object, you must define an interface, and you are effectively back to a pure-object approach.




As in my other answer to one of your question, this paper is extremely relevant:

http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf
"On Understanding Data Abstraction, Revisited", by William R. Cook

Of particular interest are section 3.3 on autognosis, which hints at why binary methods in the ADT style are strong, whereas in the object style are weak, and section 5 which explains a bit the difference between what is considered a pure object approach and the more general objects available in Java. (You can program in the pure object style in Java, but you have to follow a given discipline about not breaking certain abstraction boundaries, which relates to the discussion you've had in the comments)



I hope this makes sense, I'm sorry you had trouble with my other answer, this is a hard topic to get your head around, but once you have fixed your misunderstandings you will see it is not that complex!