Version control is very definately still relevent for single developers. Largely because of rolling back changes but also for tracking and for the other cool little things you build in to your achitechture.
Rolling Back Changes
Everyone makes mistakes. Simple fact. There will come the point when you've put an erroneous piece of code live and you need to roll back a file, or the whole project to a known valid state. Something which both CVS and SVN provide for helping this is tagging. If you get to a point where your application is working you can "tag" it as a release. If after future changes something major goes wrong you can then easily roll the live site back to the working tag while you figure out what went wrong.
Tracking
If you're as forgetfull as I am you'll forget what you changed in a file 5 minutes after you commit it. Well, you can leave a message with a commit to remind you (an others) what changed on a particular revision. This feature is very usefull for looking at the evolution of a file over time. For example, in cvs you can do cvs log [filename] to see all the revisions and all the comments left with each of them.
Other Little Things
Both CVS and SVN have loads of little features which make development easier. You can attach scripts to commits so, for example, you can require that php files pass a syntax check or any unit tests they may have before they're allowed into the repository. You can set up nightly tasks to run all unit tests on the application and if they all pass then tag the repository as a release so that you can roll back to this point if anything goes wrong.
A cool thing which I like the idea of (but still haven't gotten around to implementing) is a two branch approach where you have a development branch and a live branch (much like MarkR said but with the multiple staging in the version control system itself). So, all your developers check out from the development branch, make their changes and commit back into the dev. branch. Then, when a developer has completed a task and needs to put the work live the changes are merged from the dev. branch into the live branch. At this point the checks I mentioned earlier (or at least those directly relevent to the code being merged) can be run to make sure that the code in the live repository is always clean. The live site is then updated to take the changes from the live repository. There are a number of advantages to this kind of setup.
Your live repository is always as clean as it can be while at the same time developers can commit early and commit often in the dev. branch which keeps everyone up to date.
Nightly unit and performance tests can be run on the live repository to automatically make sure that everything is working well.
If you have multiple live servers you can easily have all sites pull in the latest changes by simply running a cvs update. No more messing around with rsync and having to wait for secondary web servers to catch up.
And this is probably the most important. You have a clean version history for the live site. If something goes wrong you can easily roll back to a fully working system in moments because you have application wide tags which are fully working. In the single branch approach you rarely (if ever) come accross a situation where every single developer is in between projects and you therefore have a clean repository.
I come from the position of working on a single, large site. I'm sure there are very different problems and sollutions when working on a large number of smaller, faster turnover projects. I'm also sure that the points I've made here aren't always going to be applicable.