New Backend Implementation

Contains:
* Concurrent and Extendable Backend Spooler
* (Experimental) Riak Backend Adapter
* (extensible) File Chunking
* various utility classes (UniquePtr, Observable template, Callbacks template,  ConcurrentWorkers template, PolymorphicConstruction template, LockGuard template, ...)

*Descriptions from Previous (deleted) Pull Requests:*
While the internal procedures are still the same, the structure of the code changed substantially. Compression and Hashing of files is now implemented as a `ConcurrentWorker` class (`FileProcessor`) which is used by the `ConcurrentWorkers` template to spread the work over all available CPU cores.
Additionally the actual spooler implementation is not forked into a child process anymore, obsoleting the named-pipe descriptions in the spooler definition strings.

*Contents:*

* A rather simple **StopWatch** class was added, allowing for time measurements using gettimeofday()

* Added a base class **SingleCopy** that defines the copy-constructor and assignment operator to be private. Therefore classes that inherit from **SingleCopy** will not be copyable.

* Added a simple **UniquePtr** template to manage pointer allocation in a RAII-fashion.

* The base class **Lockable** implements a simple mutex lock mechanism. It allows inheriting classes to implement mutual exclusive access easily, through a common interface
* Using the RAII-style **LockGuard** template one can easily create scoped locks of objects that implement `Lockable` or using raw constructs such as `pthread_mutex_t` or `pthread_rwlock_t`
* The base class **Observable** allows inheriting classes to provide an asynchronous callback interface, to which arbitrary other classes can register callback functions or methods.
* Finally **ConcurrentWorker**s is a generic implementation of a Producer/Consumer pattern that allows arbitrary *Workers* to process *Jobs* concurrently. Workers are classes that inherit from the `ConcurrentWorker` base class and define their input as well as output data and an interface to process a Job. Scheduling and synchronization is transparently done in the `ConcurrentWorkers` template. See the code documentation for further usage instructions.