ServiceHelper: change how service deps are filled

The context construction is now more aggressive about failing when
required services are not able to be filled.

A service can be marked optional by implementing the Optional interface,
in which case the context's service population will continue even if
that service cannot be filled.

For transitive service dependencies, if the dependency is marked with
"@Parameter(required = false)" then it is considered an optional
dependency which also will not halt service population with an
exception, but rather merely be set to null.

Otherwise, if a required service cannot be filled,
IllegalArgumentException is thrown. In the case of a transitive
dependency failure, the IllegalArgumentException will have a chain of
causes that clearly identify the ultimate culprit, as well as the
dependency chain which triggered the failure.

In all cases, invalid services are still logged as warnings, with a
stack trace when in debug mode.
Add tests for Context creation with services

We check that contexts get created (or not) in various situations,
with service dependencies of various natures.
Inject context and service parameters

This change allows services (and contexts, too) to be declared as
instance fields annotated with @Parameter.

They can then be automatically populated by calling
Context#inject(Object). In the case of objects which extend
AbstractContextual, it also works to call
Contextual#setContext(Context).

This capability will allow a great reduction in the number of calls to
Context#getService(Class). Right now, both ImageJ2 and SCIFIO call
getService all over the place, but it makes eminently more sense to use
this new injection mechanism, which guarantees the presence of required
services at injection time, rather than potentially seeing
NullPointerExceptions later when getService(...).doSomething() is
actually used.
Add tests for @Parameter injection mechanism

We want to make sure that *any* class which has @Parameters of type
org.scijava.service.Service or org.scijava.Context has those parameters
populated with the context's associated values, when
Context#inject(Object) is called on it. We also want to make sure that
*if* the object implements the Contextual interface, the result is
exactly the same when calling Contextual#setContext(Context).