Use SBT's managed dependencies for NER libraries

Dependencies of NER Tools (only Linnaeus at the moment) were managed manually
by placing its JAR files inside the "/lib" directory; now they are managed by
the SBT library resolver, by using a couple of Maven repositories holding them.
It will probably be a good idea (that will not be done in a nearby future) to
have a self-hosted maven repository for them.

With this change, dependencies on ABNER and Oscar libraries have also been
added.
Increment wait time for WS response in LinnaeusNER

Response from the Taxonomy WebService of eUtils (NCBI) was expected to be
received within 5 seconds. This timeout was giving some random problems while
testing, as it looks that sometimes that response will be slower.

Waiting time has been incremented to 10 seconds. I think we can safely assume
that if within 10 seconds a response from the WebService has not been received,
it will be a good idea to just report a Failure, and let client code do
whatever it wants with that.
Add tests for Oscar Annotator

Tests and basic implementation (throwing a NotImplementedError aka ???) to
allow compilation of OscarNERAdapter have been added. Since tests are mostly
the same as the Linnaeus ones, this can probably be refactored to avoid ugly
test code repetition.
Create macros subproject and update libraries versions

A "macros" subproject has been created inside the directory '/macros'. It will
hold all required macros for the main project. Those need to be put apart into
its own project since a macro definition and the code that uses cannot be
compiled in the same pass (with current scalac compiler). And, since SBT is not
smart enough to compile macros previously to its callers, the easy solution is
to create a subproject with all the macros, that will be compiled first, since
the main project is declared to depend on them.

Also, versions of different libraries and frameworks have been upgraded to its
latest versions.
Model entities refactor and cleanup

All model entities have been moved from the "*.model" package to "*.entity",
to have a simpler package structure. Also, all the subdirectories
"es/uvigo/esei/tfg/smartdrugsearch" have been deleted, since Scala does not
require to have a subdirectory per subpackage, so "package
es.uvigo.esei.tfg.smartdrugsearch.entity" can still be used, but only a
"entity" directory is used for all the package hierarchy.

Category has been changed from a Scala Enumeration to a Sealed Trait and Case
Objects that extend it. It's a bit more of code, but easier to maintain, and
cleaner. And NamedEntity has been renamed to Keyword, since it is a better name
for what that class represents.

A empty "util" package object has also been created, to be filled by util
methods and objects when needed.
Database refactor and cleaup

Database access classes and objects have been refactored, improving its design
by not having a big DAL class that holds everything. Separate DAOs are now used
for each database table, a DatabaseProfile class holds the database connection
via a JdbcProfile, and mixing in Mappers, Profile and a new Tables trait that
defines the different database tables.

Also included new tests for DocumentsDAO, and commented out all code inside the
annotator package, since it needs to also be refactored to use this new
database package design.
Add KeywordsDAO and tests

Implemented KeywordsDAO for KeywordsTable and its tests.
Add AnnotationsDAO and tests

Implemented AnnotationsDAO for AnnotationsTable and its tests.
Annotator package refactor and cleanup

NERAdapter and LinnaeusNERAdapter have been updated to use the new database
package structure: they now have an empty constructor, create a DatabaseProfile
via its factory companion object, and use the existing DAOs instead of
operating directly on a TableQuery object. Also, all previous naming refering
to "NamedEntity" has been replaced by the new name "Keyword".

Also updated OscarNERAdapter test to the new NERAdapter structure, but not
implemented yet the Oscar adapter.
Implement Oscar NER Adapter

OscarNERAdapter is a NERAdapter (Akka Actor) that performs annotations on
documents, trying to find the chemical compounds that its text holds. Oscar
uses its own internal chemical name recognizer and normalizer, so its usage is
quite simple. Each chemical compound found is normalized into InChI and stored
into database, along with the original word or sentence that was used in the
document.

Usage of this OscarNERAdapter should be similar to this:

    val oscarActor = Akka.system.actorOf(Props[OscarNERAdapter])
    oscarActor ! myDatabaseSession
    oscarActor ! myDocument

Testing is a bit slow, since no different dictionary of chemical compounds than
the one that Oscar internally uses is established. It will probably be changed
to use a small subset of its big dictionary in testing mode, allowing a faster
response from the Actor.
Implement ABNER annotator adapter

ABNERAdapter is a NERAdapter (Akka Actor) that performs annotations on
documents, trying to find important keywords in them (proteins, dna, rna, cell
lines and cell types). It cannot normalize them to an standard representation,
so the one and only thing that it does to normalize is check if the keyword has
already been stored in the database, if not it just creates it (a real solution
to this would be to use something like Mora[1] instead).

Usage of this ABNERAdapter should be similar to this:

  val abnerActor = Akka.system.actorOf(Props[ABNERAdapter])
  abnerActor ! myDatabaseSession
  abnerActor ! myDocument

The Category entity has also been modified to hold more types of keywords
(necessary for ABNER types).

[1] http://moara.dacya.ucm.es/download.html
Include ABNER resources

ABNER NLPBA trained CRF file has been added to resources. It is kept in git
compressed in "abner.tar.lzma". Remember to uncompress before doing anything
related to the ABNER Adapter.
Remove outdated evolutions

SQL Evolution files are outdated. They have been removed from version control,
and will be updated to the new Slick's Table definitions inside "*.database"
package shortly.
Database access refactor

Database access classes have been refactored. Now, DatabaseProfile holds a
Database reference, from where "withTransaction", "withConnection",
"withSession" and "createSession" can be called. This achieves a better design,
allowing easier testing and usage of the different DAOs. DAOs and Annotators
tests have been refactored to reflect this new DatabaseProfile behaviour, and
they are now a lot simpler and cleaner. Both use now the BeforeAndAfter trait
of ScalaTest in its superclasses to create a session to the Testing database,
and create and drop the database tables.

This new design of the database objects allows the NERAdapters to not need a
previous step of configuration where a Session is passed. They can now create
directly a session with the DatabaseProfile that they were already creating.
And because of that, an implicit session parameter is no longer required, since
a session can be directly created wherever it is needed.

Also, SQL evolutions have been updated and re-integrated intro Git and Akka
library has been downgraded to 2.2.4 since it looks that Play 2.2.x can't
properly work with Akka 2.3.x.
Add Annotator base actor

Annotator Akka Actor serves as a facade to all the different annotators
(NERAdapters) in the system. It just passes them the documents to annotate and
logs the results of it (if finished correctly or something failed). Now, with
this Actor, annotating a document with all annotators is as simple as:

    val annotator = system.actorOf(Props[Annotator])
    annotator ! myDocument

And that's it! All done in a non-blocking way, son client code can continue
doing whatever is required while the document is being annotated.

NOTE: It is a bit ugly to have all NERAdapters actors created "by hand",
because that requires modifying the Annotator actor whenever a new NERAdapter
is to be used.  Maybe the list of NERAdapter classes can be obtained from a
configuration file, it could be cleaner. Will try to do it that way in a
future.