A primary concern I have that I haven't seen mentioned is how we test actors without inheritance. Actors, like classes, will likely be used to manage state. From experience, the stateful reference types in programs often form a dependency chain connected to some root singleton or singletons, which are then injected into parts of the program. One of the nice things about Swift's classes, is it's very simple to create a mock subclass inside a test function, only overriding what's needed for the test. This extends to integration tests where you can chain together these inline-mocks (in the fashion expected by the application) and have very clear and concise tests written out for entire application sub-systems. I see a future where these same stateful reference type chains exist, but often as actors injected into parts of the program.
I've read previous arguments that POP is the preferred way to structure subtyping, and I have no general argument there. But in application development, in the case I'm considering, there's almost never any more than 1 primary type for 1 job in the stateful dependency chain, in which case, adding a protocol is redundant. Additionally, external libraries (such as http networking) are usually included in that chain, and often use classes as their single interface. It's then simple to test the libraries and their integration given the method mentioned earlier.
Considering this, I would very much prefer a way to subclass/subactor, if only to test actors. I think Chris' suggestion (2) "Support for inheritance but without designated/required initializers, class methods, etc." would work for most cases, as long as (a) functions can be overridden and (b) mutable test variables can be added, to the sub-actor.