Here are some things of the top of my head that I think are pretty cool:

• state variables No more scoping variables with an outer curly block, or the naughty my $f if 0 trick (the latter is now a syntax error).
• defined-or No more $x = defined $y ? $y : $z, you may write $x = $y // $z instead.
• regexp improvements Lots of work done by dave_the_m to clean up the internals, which paved the way for demerphq to add all sorts of new cool stuff.
• smaller variable footprints Nicholas Clark worked on the implementations of SVs, AVs, HVs and other data structures to reduce their size to a point that happens to hit a sweet spot on 32-bit architectures
• smaller constant sub footprints Nicholas Clark reduced the size of constant subs (like use constant FOO => 2). The result when loading a module like POSIX is significant.
• stacked filetests you can now say if  (-e -f -x $file). Perl 6 was supposed to allow this, but they moved in a different direction. Oh well.
• lexical $_ allows you to nest $_ (without using local).
• _ prototype you can now declare a sub with prototype _. If called with no arguments, gets fed with $_ (allows you to replace builtins more cleanly).
• x operator on a list you can now say my @arr = qw(x y z) x 4. (Update: this feature was backported to the 5.8 codebase after having been implemented in blead, which is how Somni notices that it is available in 5.8.8).
• switch a true switch/given construct, inspired by Perl 6
• smart match operator (~~) to go with the switch
• closure improvements dave_the_m thoroughly revamped the closure handling code to fix a number of buggy behaviours and memory leaks.
• faster Unicode lc, uc and /i are faster on Unicode strings. Improvements to the UTF-8 cache.
• improved sorts inplace sorts performed when possible, rather than using a temporary. Sort functions can be called recursively: you can sort a tree
• map in void context is no longer evil. Only morally.
• less opcodes used in the creation of anonymous lists and hashes. Faster pussycat!
• tainting improvements More things that could be tainted are marked as such (such as sprintf formats)
• $# and $* removed Less action at a distance
• perlcc and JPL removed These things were just bug magnets, and no-one cared enough about them.

update: ok, in some ways that's just a rehash of perldelta, here's the executive summary:

There has been an awful lot of refactoring done under the hood. Andy "petdance" Lester added const to just about everything that it was possible to do, and in the process uncovered lots of questionable practices in the code. Similarly, Nicholas Clark and Dave Mitchell nailed down many, many, many memory leaks.

Much of the work done to the internals results in a much more robust engine. Far likelier err, less likely, to leak, or, heavens forbid, dump core. If you have long running processes that chew through datasets and/or use closures heavily, that is a good reason to upgrade.

For new developments, there are a number of additions at the syntax level that make writing Perlish code even better. Things like Mark-Jason Dominus's book on Higher Order Perl makes heavy use of constructs such as closures that tend to leak in 5.8. If this style of programming becomes more widespread (and I hope it does, because it allows one to leverage the power of the language in extraordinary ways) then 5.10 will be a better fit.

Years ago, having been bitten by nasty things in 5.6, I asked Does 5.8.0 suck?. As it turns out, it didn't. I think that 5.10 won't suck, either. One big thing that has changed then is that far more people are smoking all sorts of weird combinations of build configurations on a number of different platforms, and many corrections are being made as a result of that. Things that otherwise would have forced a 5.10.1 to be pushed out in short order.

update: clarified the "no more foo" additions, as per dmorgo's comment.