This is a tough one. We need to have in mind that the target audience is non-programmers. As a long-time OOP developer, attaching events sheets to objects makes sense to me.
MIT's Scratch is an example of an tool targeted to non-programmer in which each sprite has its own collection of scripts. However, there are limitations as sprites cannot invoke other sprite's methods. The following statement in C2 takes non-trivial work to replicate in Scratch:
If bullet collides with ghost then
...add 1 to score
In Scratch there are two ways of going about this:
1. Both, ghost and bullet check for collision with each other and decide to destroy themselves. One of them, though, has to be responsible for updating the score. The problem here is that this approach creates a race condition. One of the sprites will determine the collision first and destroy itself; when the turn comes for the other sprite's script to execute, no collision is detected.
2. The other approach is to have one sprite to coordinate all the actions and send "signals" to the other sprite telling it what to do.
This works, but the "simplicity" seems to be gone.
If in C2 each sprite is going to have its own event sheet, then either the bullet or the ghost will handle the collision; but which one? Either way, it would not be easy to "reuse" either sprite in other projects as they depend on the presence of the other object for their sprite sheets to work. This problem will always be there with Object-based languages, as opposed to Object-Oriented languages.
For real reuse, you either move to an OOP approach, or introduce the notion of "slots" for the scripts (a kind of "generic" programming) which are instantiated at runtime. This way, you can take your sprite to another project and provide the appropriate sprites instances for those "slots". Also, you would want to have something similar to inheritance so you can really create classes of reusable widgets and sprites. Either way, we loose simplicity.
I like the idea of strengthening groups as middle-ground compromise.