Fix up a couple of memory leaks
Don't empty an already-empty list

If by some freak chance flushing_keys *wasn't* empty when we rotated it,
we're better off keeping those keys around for a second flush rather than
losing the fact that they're dirty.
Cleanup value list correctly after flushDirtyKeys

Trickiness is not my strong point.  Just iterate from 0 like a normal person.
Dupe the key we move from flushing_keys to dirty_keys on failure

Not doing this causes explosions, because the later dictEmpty on flushing_keys
will free up the sds that represents the key... so the next time we go to hit
the copy of the key in dirty_keys... kaboom.
Provide a generic function to check whether the NDS child has completed

We're going to use this code in a couple of places, so let's just break it out into
a nice generic function anyone can call.
Flush keys as often as we can during RDB load

Since the background flush will almost certainly be slower than the key load,
the number of keys in each flush will gradually go up, but at least we're
parallelising the pain.
Upgrade the freeMemoryIfNeeded-with-dirty_keys logic

We now correctly handle the case where a background flush is going on, which
we'll wait for before giving up trying to free memory.
Handle nds_bulk_put returning error

Kinda important, that one.
Provide stats on how many successful/failed dumps we've had
Turn on auto defrag

This will slow down writes, but they should only happen in the background
so who cares?
Support compressing NDS snapshots after they've been made

Disk space savings ftw
Force gzip to overwrite existing compressed snapshot files

That'll be needed on the second snapshot...
Don't blurt out an error when dumping an empty freezer

It just makes people nervous for no good reason.
Simplify walkNDS

Don't pass in val, because we rarely actually need it.  Those walker callbacks
that do need the value can get it in the most appropriate way for their specific
situation.
New command: NDS DEFRAG

Since KC defrag sucks monkey balls, lets implement our own that copies all
the non-dead keys into a new file, then moves it over the top of the existing
one.  This isn't real quick, but it is *very* effective.  We also defrag
before we snapshot, so we should get some decent periodic disk space
savings.