Add the WT error name space, fix a section name collision.
Rework WT_EVENT_HANDLERs.
    Change the WT_SESSION's WT_EVENT_HANDLER reference to be a real
structure, and copy values into it instead of simply pointing to the
user-specified structure.  The argument for using a reference is the
application can swap functions whenever it feels like it, the argument
against using a reference is that if the application allocates the
structure only long enough to call wiredtiger_open, we're going to drop
core.  We don't document that the structure needs to persist, and if the
application wants to swap functions, it can do it inside the function
it gives us, so using a real structure doesn't lose any functionality.
	Change the semantics of the event-handler error function (used
to return void, now returns int) and the progress function (used to
return int, now returns void).  Change the semantics of the erorr and
informational handlers so that if the handler returns failure, we
fallback to the default behavior.
	Document the event-handler parameters.
	Change the code so that a missing handler calls the default
handler function: that means a NULL event-handler structure does the
right thing, and eliminates the need for __wt_event_handler_default
and some initialization code in a few places, and the need to make
the default error and informational message handlers look like the
application-specified versions.
	Delete api/api_event.c, move the default informational and
error message handlers into support/err.c   Delete the default progress
message handler entirely, it didn't do anything.

	Delete include/progress.i  (The only function the file had was
the default progress handler function, __wt_progress, which is only used
by verify and salvage, the compiler can inline it if it wants.)  Moved
__wt_progress to support/err.c.
Don't use FLD_XXX for structures with "flags" fields.
We should be truncating files without snapshots to a single sector, that
is, if the block manager is opened without a snapshot, then any file
contents after the initial descriptor sector should be discarded.  This
is a normal case, where a file is created, contents written, and then
failure without writing a snapshot.  The reason we didn't truncate files
without snapshots to the initial descriptor sector was salvage: salvage
cleared the file's snapshot entries as soon as it started, which meant
that failure before the new snapshot was written would result in a file
that looked like a newly created file, and and a subsequent open of the
file would truncate it, which isn't what we want.
	Change snapshot open to truncate the file, regardless of whether
we were given a valid snapshot or not, so files without snapshots will
be truncated back to the descriptor sector.
	Change salvage to not load/unload a snapshot, the underlying
block manager salvage code can do what's needed instead.
	Change salvage to not clear the file's snapshot information
until it's ready to set new values.  This still isn't as durable as we
need to be, but it's a lot closer.
Change the cursor page's reference to "Data Sources" to be a subpage, so
we don't get a "Related Pages" category.
Doxygen has the idea of a hierarchy of pages starting with the
introduction page: every page should appear somewhere as a "subpage" of
a page in the hierarchy, which determines where it will appear in the
navigation tree on the left hand side.  Pages that aren't in the
hierarchy are put in a "related pages" tab at the top, which disappears
when empty, so if you see that tab it's saying that there is an orphan
page somewhere.
	Complain after the build if there's a page that isn't in the
page hierarchy.
Make sure inserts and updates are stored in lists before the lists are attached to a page, so that no thread sees a list that is set but empty.
Make sure appended records are stored in lists before the lists are attached
to a page, so that no thread sees a list that is set but empty.
Fix previous commit: we can't skip the search in column store appends.
Rework WT_EVENT_HANDLERs.

All 3 event handlers can now return an error (we ignore the return in the
__wt_err/__wt_errx functions, presumably those aren't being called unless
we're already returning an error).  If a handler itself fails, we report
the failure using first the application-

The big result of this change is the WT_VERBOSE macro family can now all
return errors.  Get rid of WT_VERBOSE, and replace it with
WT_VERBOSE_ERR (jump to err: on error) and WT_VERBOSE_RET (return value
on error), plus WT_VERBOSE_VOID (ignore any error) in a few places.
Remove WT_VERBOSE_CALL, and inline the test in the few places that used
it.  This change required lots of code shuffling, changing void functions
to return errors, and other kinds of cleanups.

Change the WiredTiger error-printf extension function to return an
error.  Again, I would anticipate callers to the function would ignore
the return (presumably, they're calling the error printf function before
returning an error), but there's no reason to believe that's the case,
or that the inability to inject an error message into the system isn't
fatal in a different way than the error being reported.  While I was in
the area, simplify the interface the error-printf extension uses, rather
than export __wt_eventv in all its 7-argument glory.  I also wrote some
documentation for all of the extension functions.

I shuffled the code in block-manager open/close to always unload any
snapshot that had been loaded (partially, or fully), it's better than
the caller guessing how far we got in the open process before failing.

Rename __wt_msgv to be __wt_vmsg (match the print(3)-style API names).
whitespace
Check the write generation for column store appends.
Merge branch 'develop' of github.com:wiredtiger/wiredtiger into develop
Clarify a comment.
distinguish between discard types in verbose mode.
Merge branch 'develop' into handler

Conflicts:
	src/block/block_snap.c
	src/btree/rec_track.c
Merge pull request #208 from wiredtiger/handler

Handle errors in event handlers consistently.
If walking backwards through a skiplist races with an insert, restart.
Don't repeatedly re-allocate the temporary buffer.
Change a few WT_RET calls to WT_ERR calls so the buffer is free'd on error.
Check for a race between sync requests and the eviction server.