Add basic logging

# Addressing Issues #7 

I added a basic logging module which makes it easy to use the logging functionality within the project. I followed [this approach](http://stackoverflow.com/a/6768164/583592) as it seems interesting yet satisfying for my needs.

The way we'd use this logger depends if we're working with a *class* or a *module*.

## Class
```
module GitStatistics
  class Collector
    include Logging  # Add this so the class gets logging capabilities

    def method
      ...
      logging.info "Info Log Statement"    
    end  
  end
end
```

## Module
```
module GitStatistics
  module Utilities
    extend Logging  # Add this so the module gets logging capabilities

    def self.method
      ...
      logging.info "Info Log Statement"    
    end  
  end
end
```

# Adjusting Log Level
With this approach we are able to easily use the logger just by *including/extending* the *Logging* module. As we do not explicitly create the logger we have a default logging level (UNKNOWN, to not show any log statements during normal execution). To adjust the log level it is possible to adjust the specific logger for the class/module by using the following approach.

```
logger.sev_threshold = Logger::DEBUG  # This will set the current log level of this class/module to the DEBUG level
```

To avoid explicitly setting each logger's level for each class/module, we can set the global logger's level. The current implementation of the logging module is to create a new logger for the class/module that it is called from, *unless* one has already be made. This global logging level approach will change the default logging level of *newly created loggers. In the situation where several loggers have already been used this approach will not change their logging level, in which those loggers much be altered using the aforementioned approach.

```
global_logger_level( Logger::DEBUG )  # This will change the default logging level of all newly created loggers
```

If the program's logging level is never going to change, then setting the default logging level within the Logging module would work well. In the situation where the logging level can change (either during execution, or based on parameters)  the best approach is to use the `global_logger_level()` as early as possible. When the global logging level has been change, we still have to explicitly change the logger's level of the entry class and other classes where the logger has been used. For example,

```
# First class the program utilizes
Class FirstClass
  include Logging
  
  def initialize()
    global_logger_level( Logger::DEBUG )  # Change the default logging level of all future created loggers
    logger.set_threshold = Logger::DEBUG  # Change this class's logging level
  end
end
```