Adding failing test for annotated POST payloads.

If the POST payload has any kind of annotation, it is not picked up
by the doclet. This commit adds a regression for this fact.

We discovered this behaviour when trying to annotate a payload with
`@javax.validation.constraints.NotNull`. I did not want to introduce
a new test dependency, so I tried it with other annotations. It does
behave the same way with `@java.lang.Deprecated` as well.
Allow POST payload to be included even if annotated with unknown class.

This fixes the failing test introduced by the previous commit.

The idea is that POST methods are allowed to have one weirdly annotated
parameter, as long as it's not excluded and not JAX-RS.
Remove "body" type parameter check in `shouldIncludeParameter`.

From what I understand, the call was redundant:
- in the original code, it always returned true because it was inside
  a condition of "has no annotations", and `paramTypeOf` will return
  "body" for that condition (also risking NullPointerException if the
  annotations == null)
- in the modified code all the allowed/excluded conditions are tested
  first, leaving only unrecognised annotations in the end, which would
  return "body" from `paramTypeOf` as well.

Therefore, the explicit parameter type checking is unnecessary.
Refactor: Moving and renaming things around for better visibility.
Refactor: make recorder a configuration options to fix tests.
Refactor: split up parsing without Model support.

This will hopefully clear the ground for testing and more refactoring.

Models need to be passed down and collected on the `ApiDeclaration` level.
Refactor: restructure model parsing, pass down parsed models.

This approach has revealed an issue with clashing naming: if two types
have the same `@XmlRootElement` name, they will have the same model IDs.

In the old code this was not apparent because they got overwritten in
the model collecting map, but this collection mechanism relies on
`equals`/`hashCode` to remove/skip already parsed Models.

This issue will have to be resolved somehow.
Extract type/field/method to translation class and resolve name clashes.

Conflict resolving works for JAXB annotated type names, since the other
naming is based on the qualified type name, which should not clash.
The conflict is resolved by adding "_" characters at the end until it
is no longer conflicting.

Potentially this will resolve "conflicts" between classes not related
to each other, so a resource might have a documentation with class name
ending with "_", with similar class names.
New JAXB field/method aware translator.

Next step should be fallback-chaining of translators, so it can be
chained at the beginning: try A, if null try B, if null C, etc.
Fixing findbugs error about string concatenation in loops.
Applying AnnotationParser to other places doing its job.
Adding Jackson @Json... annotation translator and chain resolver.

The "chain resolver" is `FirstNotNullTranslator`. Its `addNext` method
can be used to add another translator to the chain. As the name suggests,
the first not null value returned by the chain will be returned in the
end.
Change output to be more inline with swagger-core.

There is still a lot of things to be done:
- "api.operation.parameter.description" is not required
- "api.operation.parameter.required" is sometimes different in swagger-core
- "api.operation.parameter.allowMultiple" should be included
Adding history.
Re-adding model skipping if it has no properties.

This was overlooked in the refactoring.
Make all models use Guava for equals/hashCode/toString.
Add support for enum classes.

Enum classes will be handled as string properties with a list of allowed
values.
Move translator to options to lessen cluttering of code.
Refactor: get tools out of test class in preparation for more tests.
Clarify API resource/api grouping comment in code.