Replace all use of casock with ZeroC ICE.

This is a much nicer RPC framework that's infinitely more mature than
casock, and has protocol definition files that aren't too dissimilar from
protobufs.  Plus this one seems to work reliably with much less code
needed.  Overall, a good clean experience.
Remove BtrfsBackend, start implementing backend functionality.

This removes BtrfsBackend as a class in favor of just doing the initialization
in btrfs_backend_main.cc.  I've also decided to implement the various on-disk
file formats for configuration and hashes as protobufs, as these are really easy
to read in and work with.
Add more of the protocol; use serialized ICE objects for saved files.

This change adds more capabilities, like being able to query and create backup sets
from the client, and to have the backend actually return useful data.

Additionally, this change removes all use of protobufs and instead uses serialized
ICE objects.  This avoids having to duplicate these structures.
Move a lot of the stuff that was in client into backend.

Much of the stuff that was in client is actually part of the backend.  The
BTRFS backend just happens to be in two parts -- a server program that runs
on a remote host, and a module that interfaces with the client application.
The client application instantiates an instance of the backend it wants.
Makefile formatting changes.

This makes the targets in the various makefiles a bit easier to see.
Lots of cleanups, a few new commands.

 * Made the CLI command handling a bit more clean, implementing each
   command as a separate function.  TODO: add a map of command to
   function and add help.

 * Converted all boolean-returning RPC functions to return a Status
   object indicating success or a detailed error message.

 * Added a base/ice.h which can be used to uniformly initialize ICE,
   registering any class operation handlers as necessary.

 * More comments and general clean-up.

 * Added a CreateIncrementalBackup command with a stub implementation
   that currently fails for no reason (the implementation in BTRFS
   always returns a NULL Backup object).
Make the library build target names make more sense.

This brings the library build target names into more of a formal naming
convention of path.to.my.libary_target.
Find ICE in non-standard places

Also fixes a dependency problem.
Add simple help to the CLI client.

This should really be auto-generated by the commands themselves in
CliMain() as a static function.
Lots of cleanup, additional functionality.

This change separates out the client and server-side functionality
of the backup set, and implements various client-facing functions
that activate server-side RPCs to execute actions.  This allows a
BackupSet created on the client to affect server-side actions without
requiring access to the server implementation.

There's still a lot of cleanup that needs to be done -- the client and
server halves of the backend are very much intermingled and need to be
separated out.
Separate client and server halves of btrfs backend.

This change separates out the client and server halves more explicitly,
allowing better clarity of what's going on.
Implement support for creating backups into the backup set descriptor.

This doesn't implement full support for creating backups, but does
implement the following:

 * Creating incremental and full backups as initiated from the client.
   The client still returns NULL, as there's no way to convert from
   a proto Backup to a client Backup*.

 * Creating the directories in the backup set for the backup and adding
   the backup to the backup set descriptor.

 * Saving and loading the backup descriptor contents.  Turns out to save
   an identity, you need to make a class, not a struct.  Go fig.
More functionality implemented.

 * Move to using completely UUID IDs to represent and reference backup
   sets and backups.  This allows backup names to be as descriptive as
   desired, and also to allow them to be non-unique.

 * Implement ability to enumerate backups in a backup set via CLI tool
   and in the backend.

 * Initial implementation of the BTRFS backup class.  Currently it can
   be created and destroyed, but doesn't do much else.

 * Fix an issue where backup sets were being re-initialized every time
   a backup was created.  This caused the last-created backups to not
   be saved if modifying an existing backup set, as the descriptor
   would be re-read each time, killingo off the new data.
Start making backups more useful.

This converts the Backup proto class to a client-accessible class with methods.
In doing this, I found an issue with dependencies between the client and the
backends where server-only resources were being included in client code and
vise-versa.

I've also cleaned up a bit of the ICE communcicator and adapter usage.  The
communicator and adapter created for the btrfs backend server will be the
only set ever used, so a simplifying measure is to store them in a singleton.
This way, all client/server objects can make use of it easily to create
and manage proxies.
Split out the backup_descriptor.ice file, it was getting huge.

The backup_descriptor.ice file really should only have stuff relating to
the backup descriptors -- backups and backup sets should be their own
protos.
Move all the server-side ICE files into /proto

Now that the proto libraries and their implementations are separated out, these
can be all stored in the /proto directory to clean things up.