File class members are encapsulated, and internal lock was added.

A lock was added to the file class to properly handle multiple threads accessing the self encryptor. Actual chunk storage and incrementing is still a work in progress.

This technically completes JIRA ticket MAID-153 too.
Currently, I do not believe this to be possible. Every element in children_ is a `File` or `Symlink` (directories are stored as `File`, which is another confusing matter that will hopefully get corrected in the future). If a directory were present, deadlock from calling into this function again would be a good thing as infinite recursion would likely result anyway (the Directory structure would not be a tree). Hard-links cannot reference directories for this reason. Symlinks shouldn't traverse to the directory during Serialisation to prevent the recursion case too.

The other deadlock case would be when the virtual Serialised method invokes any functions in this Directory class. I do not believe this to be possible at present, but its possible that a future edit could make that situation possible, especially since the callstack goes back to `DirectoryHandler` for the `Path::Listener` calls.

A solution would be to copy `children_` with the lock held to a vector on the stack, and then loop through the stack vector with the lock not held. I am for this change, but I am curious what others think about the extra allocations required for this. With large directories it will be expensive as the loop has to be iterated twice (once to copy, once to call into child). I think the current implementation _must_ be changed, because the Serialise method can eventually release the lock in the child serialise method, which allows `children_` to be modified. If `children_` is modified it could invalidate the iterators, causing undefined behavior in the range loop. An alternative that would have no copied vector, and no undefined behavior (to my knowledge) could be:
```c++
{
  std::unique_lock<std::mutex> lock(mutex_);
  for (std::size_t index = 0; index < children_.size(); ++index) {
    const auto child = children_[index];
    lock.unlock();
    child->Serialise(proto_directory, chunks);
    lock.lock();
  }
}
```
Which I believe is exception safe, and thread-safe. However, children could be removed while iterating, resulting in some children being visited twice.