ServiceHelper: populate annotated Context fields

This is not necessarily useful by itself. But it will be necessary
to at least not choke on annotated Context fields very soon, when
AbstractContextual (superclass of AbstractService) introduces one.
Context: update javadoc for inject method

The injection also subscribes to events now,
which definitely needs to be explained.
EventService: mention Context#inject in javadoc

The EventService#subscribe method talks about
AbstractContextual#setContext, but equally viable is Context#inject,
which is actually more flexible since it works with any object.
Context: tweak comment
AbstractService: never call super.setContext

This change makes it more clear that AbstractService diverges from
AbstractContextual in its handling of @Parameter instance fields, and
fleshes out the reason why this is so.
ServiceHelper: include class name with field

This is helpful in knowing exactly where the culprit is, in case of
failed context creation.
Simplify execution flow of context injection

Previously, the relationship between Context#inject(Object) and
[Abstract]Contextual.setContext(Context) was rather hairy. Each one
called the other, which could potentially result in undesirable
behavior, particularly double injection, which while generally harmless
could have negative performance impact.

The new approach is for all concrete implementations of Contextual to
simply delegate to Context#inject(Object) in their setContext(Context)
method. This now makes it dirt easy to implement Contextual (which e.g.
ImageJ2 needs to do in several places).

This change also makes injection more militant, throwing
IllegalStateException if *any* context was previously injected. It
detects this by checking whether all @Parameter annotated fields are
still null; if not, it assumes there was a previous injection and throws
IllegalStateException. The javadoc has been updated to clarify this.

This refined injection behavior should help bring more bugs
(particularly performance problems) to light earlier, in cases where
Context#inject(Object) is called on an object in multiple places.
ContextInjectionTest: use empty context

Specifically, the testNonContextualContextParameters method does not
need a FooService in its context; we test with an empty one instead.
ContextInjectionTest: verify 2nd injection fails

An IllegalStateException is supposed to be thrown when
Context#inject(Object) is called a second time on the same object.

(The exception is if that Object has *no* @Parameter fields to
populate, but in that case, the issue is rather moot anyway.)