I don't actually want to get drawn into this, but one point would be that it's really just the same fallacies as OOP in general, but concurrent. The idea that isolation behind an interface (message passing or not) is going to prevent unnecessary mutation or side effects from getting out of control.
In practice, it doesn't do that at all and the fact that you're making your inter-dependencies more implicit, rather than explicit, through the use of isolated buckets of side-effecting state and mutation is going to make it harder rather than easier to debug the program when it invariably breaks. I'd rather get a call-stack if I'm going to abandon Haskell-y goodness. And your Actors *will* get into a bad state, so you'll end up writing Inspector and Debugger mixins just to keep a handle on the complexity when they get into that bad state.
It's not impossible for Actors to make sense. I used agents (which are not full-blown Actors per se) in Clojure for side-effect isolation, serialization, and thread safety to good effect, but I kept how much "work" they did to a bare minimum and tried to keep everything in pure functions as long as I could.
It's just that I see programmers with a shiny new hammer looking for every nail they can find.