First set of snapshot changes, ref #167.  The big changes are to create
snapshot load/unload APIs in the block manager, move the free-list into
the per-snapshot information, and move the snapshot code into block_snap.c.

Create the WT_BLOCK_SNAPSHOT structure, including allocation/delete
lists.  We still only support a single snapshot and this tree doesn't
fully run (we're not yet using the allocation/delete lists).

The file's description sector is never updated, now, it's written once
and never modified (we moved the freelist out of it, there's no longer
anything in it that changes).

Generalize the block manager's addr/buffer packing/unpacking functions
to support snapshots, add to/from snapshot packing/unpacking functions.

Change "evict_file" serial function to be" sync_file" (just a naming
cleanup).
Don't force the delete percentage to 0 (so salvage runs), if the
configuration says differently.
update a comment, no real change.
By moving the free-list into snapshots, there's no longer an issue of
hitting the end of the file and being unable to write the free-list.
If that happens, we were unable to write the snapshot itself, and that's
OK, we'd revert to a previous snapshot.
Second set of snapshot changes, ref #167:

Start using the alloc and discard lists instead of running everything
through the single avail list.  This primarily affects what happens when
a snapshot is deleted.  A snapshot's avail list is discarded; alloc and
discard lists are rolled-forward into the live system's corresponding
lists, and then the alloc and discard lists are checked for overlaps,
the overlaps are the blocks that are newly available for re-use.

Change extent writes to always append to the file (the problem is that
we can't allocate the avail list blocks from the avail list, and it's
simpler to always extend the file for extent lists rather than try to
figure out which extent lists writes are extending the file and which
aren't.)  This implies that we can tell the allocation code to always
extend the file, and the free code to simply put the free'd blocks on
the avail list, because extent blocks don't appear in the allocation
list.

Change page reconciliation to release all pages in the page-tracking
information before writing a snapshot, the underlying system has to be
fully consistent.  We can no longer retain currently unused overflow
pages to re-use, across reconciliation calls: if a reconciliation call
results in a snapshot, any overflow page not used as part of the page
reconciliation must be discarded, otherwise the underlying snapshot
won't be completely consistent.  This adds some (very!) few cases where
we don't re-use overflow items we would have re-used in earlier versions
of the system, but it shouldn't be common.  This required an extensive
re-work of the block/overflow page tracking code.

Changes for salvage: load and unload snapshots during salvage, blocks
free'd during salvage do not appear on the allocation list, so must be
free'd explicitly to the system's avail list.

Rename block-manager page type WT_PAGE_FREELIST to WT_PAGE_BLOCK_MANAGER.
We still handle block-manager pages in the btree layer during salvage,
but we could also handle them in the salvage code if we're willing to
look at the page type.

Set the snapshot field names when cracking the buffer cookie.

Don't display the by-size extent lists by default, it's not very useful.
Snapshot changes, ref #167:

Add a read-only flag for snapshot load: if we're loading a snapshot for
writing, truncate the file to the snapshot's EOF value, if we're not
loading a snapshot for writing, don't bother reading the avail extent
list.

Add a verify flag rather than use the fragbits array as the verification
boolean.   Add a snapshot-load verification routine that reads the avail
and delete extent lists and adds them to the fragment list, we should not
see those blocks in the tree.
Rename WT_BM_MAX_ADDR_COOKIE to be WT_BTREE_MAX_ADDR_COOKIE, it's really
a Btree imposed limit, not a block-manager value.
Delete the code which discarded each extent list before it was written;
that code was intended to avoid allocation from the avail list when
writing the extent lists, but the force_extend flag to __wt_block_write
fixes that problem, discarding the extent list is not only unnecessary
but wrong, in the case of writing a live snapshot with an avail list,
ref #167.

Move the extent offset, size and checksum into the WT_EXTLIST structure
instead of storing it independently in the WT_BLOCK structure.
Wordsmith a comment.
Don't set or check the live_load flag for read-only snapshots (not
really a change at the moment, but will matter when we support more
than a single active snapshot).
whitespace
Don't set the operations percentages if we aren't doing operations.
Change btree salvage to load/unload snapshots rather than doing it under the
covers in the block-manager code, makes salvage consistent with verify.
whitespace.
Check for offsets that are too small.
If the file is empty, we never create a root page and there's nothing
to evict.
Initialize the snapshot structure's root offset to WT_BLOCK_INVALID_OFFSET.

Minor comment restructure/cleanup.
We can't use WT_BLOCK_INVALID_OFFSET as an out-of-band offset in the
offset name space, 0 is a valid offset to store (it's the result after
you subtract 512B and divide by the file's allocation size).  Instead,
use a size of 0, I'm pretty sure we're never going to write blocks of 0
bytes.

Don't initialize the snapshot structure's extent list names in
__wt_block_buffer_to_snapshot(), that was done when the snapshot
structure was initialized.
Don't make arguments to crack location cookies optional, it's more
trouble than it's worth.
Merge branch 'develop' into snapshot