Inheritable annotations feature

Did some refactoring and merged some other branches/features.

Now we have some inheritable annotation (the one that are defined on classes); you also defined some unit tests on `Reflection` class, and I can image a use case, but we didn't test the use case, as an end-to-end test on how the user would use the feature. So I need an "end-to-end" test, testing things as the user would use the API: defining the interfaces then using the ConfigFactory.create() and checking the results.

Something like:

```java

    public class InheritableAnnotationsTests {

       @AllTheAnnotationsHere
       public ParentConfig extends Config { ... } 

       @AllTheAnnotationsHere
       public DaddyConfig extends ParentConfig {...}
 
      @AllTheAnnotationsHere
       public MummyConfig extends ParentConfig {...}

       // and we need to think to all the possible cases of inheritance and multiple inheritance, verifying that the
       // result complies to the expected behaviour
  
       public ChildConfig extends DaddyConfig, MummyConfig { ... } 

        @Test
        public void testBlahBlah() {  // this test is an end-to-end use case, how our users would use the library
            ChildConfig cfg = ConfigFactory.create(ChildConfig.class);
            assertSomething(/* verifying that the inherited annotations are taking place as expected */);
        }
       // we need to test all possible cases that comes to our mind to ensure all possible allowed uses are covered
    }

```

Also, before releasing, we should document these new use cases. Having unit-tests for use cases, is also helpful to show some sample code.

Also we need to think about the annotations defined on methods. May they also be inheritable? 

When all things are covered, and the feature is completed, then I should merge things on master for next release.