Add NER Sentence class and tests

A Sentence is just a sequence of words that will represent an annotated text in
a given document. It could have been done directly with a String, but this way
the trimming of spaces is abstracted out and equality comparison does not take
those into account.
Add NER Category and Position classes and tests

A Category is just an Enumeration which holds the different types of categories
for Named Entities found by the annotators. Currently holds a small set of
possible categories, and will probably grow in a future to hold more as needed.
It could had also be done with a sealed trait/abstract class and a set of case
objects that extend that, but by using an Enumeration, the really useful
`withName` method is already provided. The inconvenience is that Category is an
object, and thus does not define a type, so an `import Category._` is needed
wherever it will be used.

A Position is just a Value Class over an Integer that helps to reason about the
code when using it to mark the position of a Named Entity found in a Document.
It checks that the position is a positive integer, and extends the Comparable
Trait to allow easy comparison between positions (equality and hashCode are
given by Int because it is a Value Class, aka extends AnyVal).
Redesign directory/package structure

Previous package structure did not resemble the system needs, so it is
restructured to bes suit them. Mainly, classes that were in *.model.ner are now
in *.model.entity, because those three were just Entity classes (Category,
Position and Sentence).

This structure poses a better organization of the different classes that
conform the system according to what responsibilities them have. It is not
fully stabilized, so it's actually open to future rearrangements.
Add Document entity class and tests

A Document is just an entity class that holds a title, a text and an
identifier. The class doesn't actually do anything, just checks that its
constructor parameters are OK and holds its data. It acts as an in-memory
representation of a real document (probably stored in the database), to be
annotated, or already annotated, with its correspondent named entities.
Make Position value class final

Position class is now final, preventing inheritance from it.
Add Identifier value class

An Identifier is just a positive integer (represented via a Value Class) that
will be used in all Entity classes that need to have an ID. Having this class
frees all the Entity classes that need an ID of the responsibility of checking
if a given Integer (maybe passed in in its constructor) is a valid ID
(positive).

The one and only thing that Identifier does is hold a positive integer, and of
course validate that its constructor parameter is one of those.
Make Document use Identifier as ID and Sentence as title

Document is modified to be a final class (disallowing inheritance from it), to
use an Identifier value class as its ID instead of a plain Integer, and to use
a Sentece class as its title instead of a plain String. Using an Identifier for
ID frees Document from the responsibility of checking if a given value is a
positive Integer, and using a Sentence as Title frees it from checking if it is
empty and the future need of trimming white spaces in it (to cleanly store it
in the database).
Add SLF4J-Nop and ScalaMock dependencies

Slick uses SLF4J for its own debug logging, so an implementation is needed.
SLF4J-Nop provides an implementation that just does nothing, so it actually
disables logging from Slick. This is good actually, since it is not needed at
the moment. It will be replaced in the future by another logging framework if
its outputs were needed.

ScalaMock is a framework for creating Mock objects (for testing purposes) for
Scala. It has ScalaTest support, so that it can be both easily integrated.
Current ScalaMock does not have a compiler plugin like previous ones (for Scala
2.9 and older), so it is a bit more limited, but it will probably be enough.
Add Annotation entity class and tests

An Annotation represents an annotated named entity in a document, meaning a
sentence that has been recognized by a NER tool inside a document text. It
holds an identifier, the original sentence, that same sentence normalized (to
an standard representation, eg: "person", "boy", "human"... all could be
normalized to "homo sapiens"), a Category (as defined by the entity
Enumeration) that holds the type of the annotated sentence, a reference to the
document that was annotated with it and absolute start and ending positions of
the original sentence in the document text.
Remove SLF4J-Nop from dependencies

It is not required, since Play Framework already provides an implementation of
SLF4J (a real one, not just a Nop). This dependency just makes conflicts with
that one, so it's better to just use the play-provided logging framework.
Add Virtuslab Unicorn dependency

Unicorn is a small library that enables writing type safe primary and foreign
keys in Slick applications. It is written to be used with Slick 1.x, support
for Slick 2.x is in development (Slick 2.0.0 has been released just a month
ago), so Slick dependency is downgraded also to 1.0.1 to accommodate.

Also added Play-Slick dependency, a library that makes Slick a first class
citizen inside the Play Framework, and established JDBC as a dependency to Play
Framework.
Add Play Framework config file

Application.conf inside "conf" directory establishes the configuration for Play
Framework. The only important stuff there is the configuration of the database:
default one has been set to a MySQL DB in localhost, and test is set to a H2
Database (in memory); and the final line that tells Slick where to look Scala
files that define tables to generate Play Evolution's SQL Files.
New model package structure and refactoring

Entity classes have been moved to *.model in favor of using a *.mode.entity
package, since it will be simpler this way. Category, Position and Sentence
also have a new implicit definition in its Predef sub-objects that enable
to/from database type conversions via Slick's TypeMapper.
Remove Identifier and modify Document and Annotation models

Identifier class is no longer needed, since Unicorn library provides a type
safe BaseId and IdCompanion traits that can be used to define Identifiers for
each model that needs them. So it has been replaced by DocumentId and
AnnotationId. Annotation and Document classes are modified to be in sync with
the deletion of the Identifier class.

Defined Documents and Annotations SQL Tables via Slick Table definition. These
are subject to change since I think they are not properly defined: maybe split
Annotations table in two, one that relates Documents with Named Entities and
holds the original text and positions and another that defines the Named
Entities and holds just an ID and the original text.