That's actually not how it works. Think of it like this: you have a piece of real world paper, and a stamp. It doesn't matter what angle the stamp is at when it touches the paper - the gpu calculates it in real time when drawing the pixels, and needs to make no modification to the stamp itself to do so, and it incurs almost no performance hit in the process, because gpu makers have optimized the operation like crazy.
Actually, it depends less on the GPU makers/drivers (outside of stability) than the technology being used - in this case, HTML5/JS through C2. C2 isn't a 3D engine. Yeah, some things are similar in terms of what goes on GPU-wise, but different things work different ways. Either way, wasting cycles rotating an object to save a few kb in a bitmap isn't worth it in this day and age, where even our slowest smartphones are faster and have more memory than the hardware available at the time when rotating sprites to save a few bytes was even a relevant discussion.
If it worked the way you suggested, practically no 3d game would be possible because every single texture on every polygon of every model is being distorted in an uncountable number of permutations based on perspective, angle and animation. It would use a ridiculous amount of memory to do so and would be completely pointless as very little of the saved work could be used ever again. Even if instead of saving an extra copy of the texture it just overwrote the original, the quality of the texture would degrade as it got blurrier and blurrier from being filtered over and over again.
3D uses UV mapping on a per-vertex or per-triangle basis in general, for starters, so it's not even close to comparable. In fact, it's a bit like comparing apples not to oranges, but to, say...a polar bear. I'd be happy to PM you a few links on the subject if you're interested in learning how different it is. I think a couple books I wrote on the subject that were published by actual book publishers might still be in print. They're kind of old, but the theory is the same.
Also, doesn't C2 use quads for drawing in canvas2D? In which case, it's WAAAY different than 3D.
*EDIT: It does: https://www.scirra.com/blog/58/html5-2d ... e-analysis
Maybe you were thinking of projection mapping? That's sorta-kinda stamp-like.
Also, when not using webgl, canvas2d is used which is still hardware accelerated, just not as efficiently. Even software rendering such as chrome uses still doesn't need to use more image data in memory to rotate a sprite because it emulates the real time process hardware acceleration uses.
As I think I said somewhere in a previous post, that depends on what kind of rotation we're talking about. And considering the inefficiencies inherent with the 2D canvas, the tradeoff isn't worth it because, again, the savings are minimal memory-wise (and really, who cares about 8MB when even a phone capable of running C2-based stuff from 2 years ago has significantly more memory) and could potentially have a negative impact on the actual, real-world performance of games we make by worrying about other things like sprite rotation in a sprite sheet (aside from the whole power of 2 thing someone else mentioned). If you're THAT WORRIED about performance, maybe look into learning to use the tools that are available, right this second, in a more efficient way. A couple megs on a sprite sheet isn't going to hurt anything. If it is, you're doing something wrong.
I would wager a majority of performance issues are the result of user error. Every time I've wanted to blame C2 for a framerate drop, it's because I've actually been the one doing things wrong. All it takes is a trip to the manual, or these forums, and a few keywords. People are here to help find solutions, and are almost always pretty friendly about it, but it'd be great if we could steer clear of blaming C2 for not having a feature that isn't completely necessary and may in fact be hurtful to its performance.