OpenGL 4.0 – Are we really there yet?

I was thrilled to witness the release of the OpenGL 4.x specification over a year ago. It was really exciting to see how clean the specification was with the removal of so much of the fixed-function processing and other ancient, deprecated features; but a few things still have me worried.
Because of modern OpenGL’s focus on the GPU (with vertex shaders, et al.), it is impossible for weaker PCs to utilize these specifications, since they are simply incapable of the kind of graphics processing required. So what are these weaker computers (and there are more that don’t have an advanced GPU than those that do) supposed to do?
It seems that they must stick with an outdated API with fixed-function processing and an unwanted OpenGL matrix stack. We’re talking OpenGL 1.4. If it were just existing computers that were limited, I wouldn’t have a problem; but many new computers that haven’t even been conceptualized yet will be too weak to use the modern API as well.

I am currently developing a game engine with OpenGL 1.4, and am a bit perplexed about exactly how I should go about rendering my objects.
Normally, you would manipulate the projection and modelview matrices with calls to gluPerspective() or glOrtho(); and glTranslatef(), glRotatef(), and glScalef(), respectively. You could then draw the vertices with glDrawArrays().
What if I want to take exclusive control of each vertex’s position, manipulating it by my own matrices? If my only option is to multiply my matrices on top of OpenGL’s matrix stack with glMultMatrix(), then so be it; that would be a tolerable compromise. But if there is a way to disable OpenGL’s matrix stack completely, that would almost alleviate all of the worries I have.

So what about those of you who wish to make simple 2D games that can run on any PC? These games don’t need intensive graphics processing, but could certainly benefit from modern rendering methodologies. I guess we’ll just have to deal with some of the inconveniences of a decade-old API…for now.

It seems that the transition (or lack thereof) to OpenGL 2.0 and beyond is rather harsh.
Am I looking at this all wrong? Your thoughts would be very much appreciated.
I wish I didn’t have to be so pessimistic, but I just don’t see this problem going away any time soon.
On a brighter note, with the advent of so many amazing new technologies, maybe it will just take some time for things to settle down and find where they really belong. All good things take time.