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.
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).
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.