Personally I started to think (doing mostly Python) classes are more like namespaces or modules. And inheritance is just about making code more compact by placing "overloaded" methods and data (do not do this!).

The problem with inheritance is that it makes one relation central while problem domain may have several. And even with mixins, there is very quickly a big mess.

Alternative? Some kind of multidispatch and component architecture capable of it.

Polymorphism is cool thing, but it's not limited to OOP.

Encapsulation? Also not quite limited to OOP. Modules do it as well. It's just about abstraction level boundaries, which can be as well kept by convention.

In enterprise level systems it's rare one has Cat and Dog classes. It's more usual to have a game of Spore where the user do those. Thus "OOP" gets lifted to the user level where it probably belongs. At the level the programmer deals with I see classes are more like components, which ones get by name from some registry.

As someone else already commented, classes are more like organizational principle for the code.

As for combining several functions with roughly the same arguments advice. It's quite shallow. In particular case it may reveal a better abstraction or then not, just adding some incidental couplings. (the same may be true for instance for FP languages where a module may contain functions on some "topic"). Thus a tendency for god classes.

The main critique towards OOP nowadays is whether it's a good idea to have shared state all over the system? Component systems may overcome that by having centralized bookkeeping of component instances, but what about OOP in general?

Without behavior a class is just a template for a data structure.

In a sense, an instance of the class can be understood as a "stateful function" (sounds ugly). Is such a thing really helping to fight complexity or the other way around? As with every tool - it depends.

Ergonomics is yet another dimension. Does having classes help a programmer to juggle less items at any time (and I include reading code here, not only writing)? I do not know the answer. May be, it depends on the case as well.

Possibly, having to call methods instead of classes is just a syntactical sugar. In Python it's very clear:

obj.method(args)

vs

function(obj, args)

Why obj should be privileged? Who knows... One needs to read volumes of OOP wisdom to get to it.