initial commit
added a license (Apache v2)
first working version of the AnnDocuGen tool
added a simple build script
added field initializer reading and more examples
moved field initializer reading from custom ANTLR parser to Compiler Tree API

This sounds like it ties the implementation to the Sun Java Compiler,
but this tie was already in place with the previous implementation. In fact,
this implementation only relies on public APIs, even if they are
vendor-specific, while the old one relied on a private implementation detail
of a vendor-specific class.
handle Optional types properly

Proper handling of Optionals means:

1. Deciding if something is Optional is not based on comparing strings
   but actual types.
2. If a field is Optional and has no initializer, it is implied to be
   initialized to Optional.absent
handle primitive types properly

Fields of primitive types are always initialized even if the field declaration
has no initializer expression. In that case, the field is initialized to
the default value (false, 0, 0.0, '\u0000'). This means that properties
of primitive types are never mandatory.
don't claim the annotations and don't throw exceptions

Previously, the AnnDocuGen annotation processor returned true, because I didn't
really understand what the return value means. Returning true means that
the processor "claimed" the annotations and they won't be passed to other
processors to process. This is not what I want.

Also, when handling errors, there are no longer any exceptions thrown, so
it's not needed to have the universal catch.
separate @Inject from @Property

Turns out that in the real project, injecting properties via @Inject @Property
is not going to work. Instead, @Inject will be used for dependencies and
properties, marked with @Property, will be handled manually. This changes
the annotation processor to handle the new situation, and even issue a warning
when the combination of @Inject @Property is encountered.
document qualifier annotations

Dependencies injected via @Inject can have qualifier annotations that affect
the injection process. Qualifier annotations is an annotation that is itself
annotated with @Qualifier. These annotations are now visible in the generated
documentation, together with possible parameter values.
use short type names in the documentation

Currently, the documentation prints fully qualified names of all the types.
That's not very user-friendly; instead of "java.lang.String", the documentation
should only have "String". Other cases are even worse, such as
"java.util.Map<java.lang.String,java.lang.String>".