Improved error wrapper docs.
Remove accessors to `sftp_channel` private members.

The `sftp_channel` class was exposing its privates publicly via two accessor methods, `session` and `get`.  Obviously bad.

This commit removes those accessors.  A side effect of this is that most SFTP filesystem operations become methods of `sftp_channel` as they need access to the channels private members.  Really they always should have been methods as they are intrinsic to the nature of a filesystem, not higher-level operations implemented in terms of what a filesystem offers.

A similar side effect is that instances of `directory_iterator` are now created via `sftp_channel`.  This is because the iterator implements intrinsic operations of the channel so it makes sense that the channel creates the iterator as an extension of itself rather than the iterator taking the channel as a parameter.  The latter would imply that the iterator operated on the public interface of the channel, which it does not.

The same change should be extended to the SFTP stream classes but that remains for a future commit.  For the moment, they are made friends so that can access the channel's privates.
Renamed `sftp_channel` to `sftp_filesystem`.

The new name better reflects what the class represents.  The users couldn't care less that the class is implemented over an SFTP channel, just that it gives access to a remote filesystem.
Renamed `ssh::sftp` namespace to `ssh::filesystem` to reflect its mirroring of Boost.Filesystem.
Fix keyboard-interactive authentication error reporting.

We forgot to pass the error code to `ssh::detail::libssh2::userauth::keyboard_interactive_ex`, so failures to authenticate were being thrown as exceptions rather than prompting the user to try again (we think).  Also we were passing a session parameter to `translate_status` that we no longer need to process errors.
Removed `ssh::agent`, `ssh::host_key` and `ssh::knownhost` namespaces.

Moved their contents to top-level `ssh` namespace.  There was no real reason for these namespaces and they made the implementation more verbose (especially accessing stuff in `ssh::detail` from within them).  Also renames some classes to make them stand along better now their parent namespace no longer describes them.
Manage internal session lifetime with custom RAII class.

This is clearer than using `shared_ptr` because of the session's two-step startup.  Also, this will make it easier to add session locking for thread-safety in the future.
Make use of same session from multiple threads safe.
Fix non-thread-safe SFTP object destruction.

There was a bug in our session locking where the session could be locked during an operation on one thread and meanwhile another thread was destroying a libssh2 file handle or SFTP channel.  The destructors weren't locking the session so they would not wait for the operation that had locked the thread to complete.  This would corrupt the session and lead to all kinds of nastyness.

This change fixes the problem by giving file handles and SFTP channels their own RAII classes that gracefully handle their shutdown (instead of relying on `shared_ptr` which makes it less clear what's happening) and lock the session before doing so.
Reducing large test data size to speed up unit tests.

Still multiple buffers worth.
Remove redundant external session locking.

It's no longer needed now that the ssh library handles it internally.
Make sessions create the `sftp_filesystem` instances to better reflect their relationship.

`sftp_filesystem` is not implemented using the public interface of `session`, yet passing the latter to the former's constructor implies that relationship.  Really, `sftp_filesystem` is an extension of `session`'s intrinsic function so it should be up to `session` to create them using its privates.
Encapsulate agent state in RAII class.

Makes the two-stage startup/shutdown much clearer.  This will also make it easier to implement the planned changes to the session copy semantics.
Prevent `host_key` depending on `session` lifetime.

Instead of storing a reference to the session and copying out data on demand, the commit makes `host_key` copy all the data from `session` (actually `session_state`) on construction.  This means `host_key` doesn't depend on the session being alive afterwards, which will make our planned changes to session lifetime less disruptive.

The performance impact should be minimal.  The data is just copied from the session.  No extra calculation is needed and certainly no trips to the network.
Make non-owning functions take state by reference.

Some functions were session, sftp and file handle state as a `shared_ptr`.  This implied that the functions would need shared ownership of the objects, but they only use the objects and return.  This commit makes them take references instead, making clear the role of those parameters.