Implemented CoreMetadataAdapter

Created a CoreMetadataAdapter and CoreMetadataWrapper to follow the
LegacyAdapter pattern of maintaining backwards compatibility.

Currently only the Legacy to Modern direction of wrapping is supported.

The SCIFIOReaderWrapper was updated to take advantage of this new
adapter.
Refactored format name/suffixes to Format

Previously, the format file name and associated suffixes were being
tracked via a separate FormatHandler API, and included in several
components (e.g. Checkers, Writers) as needed.

This leads to repetition of code as each component is tracking the same
format. Instead it is logical that the actual Format interface be the
maintainer of format name and suffixes.

Thus all such references were migrated to the Format interface.

Static utility methods intended to operate on the format name and
suffixes were migrated to FormatTools.

All references and constructors were updated as appropriate.
Removed AbstractParser.metaClass

The AbstractParser class was keeping track of its Metadata class, to
avoid type erasure.

However, this information was not being used anywhere, and was private.
It is also unnecessary given that getFormat() can be used to find or
create a new, appropriate Metadata object.

Thus it was removed from the abstract and all implementating layers.
Removed getZCTCoords from Reader API

The getZCTCoords method is, in general, a convenience for the static
FormatTools.getZCTCoords method and it seems unnecessary to make it a
part of the Reader API when it is typically just delegating to a utility
class.

If a format requires specific behavior for such a method, it can
maintain it within its own utility class.
Refactored static-context to be Legacy only

The single, static context located in ome.scifio FormatTools was
removed. Context can be created as needed for SCIFIO code.

In the legacy layer, context creation is modeled after ImageReader - in
which a list of readers is parsed once and statically cached. Using this
philosophy, a LegacyContext class was added, with a get() method to get
the current context.

The LegacyContext context (SCIFIO object) is created once and statically
cached.
SCIFIO Formatting: removed unnecessary "this."

Removed superfluous "this." references from core SCIFIO classes, to
enhance readability of the code.
Converted FakeReader to a delegate

The loci.formats FakeReader has been marked deprecated and converted to
a delegate. It now passes all functionality through the ome.scifio
FakeFormat collection of components.
Improved Exception handling in ICS/APNGFormats

Updated the SCIFIO Formats that were imported from the legacy scifio
branch (APNG and ICS) with improved exception handling.

Both now properly use SLF4J logging in their exception handling.
Improved loci-legacy exception handling

Implemented better exception handling in loci-legacy component classes.
LegacyContext and AdapterHelper now use the SLF4J logger to print error
messages instead of just silently eating exceptions.
Moved ICS key, value parsing to Metadata class

Previously the ICS to OME-XML translator contained all the logic of
extracting information from the ICS key,value pairs - the
ICSFormat.Metadata class was simply a bag of these pairs.

However, there is nothing mandating that this logic be OME-XML specific.

This refactoring moves all the logic from the translator to
ICSFormat.Metadata via a series of getters. No values are actually
cached, but instead when a getter is invoked, the bag of key,value pairs
is interrogated as appropriate for the requested metadata value.

The ICS:OME-XML translator and ICS:CoreMetadata translator have been
appropriately updated to call these getters.
Added basic CoreMetadata modern->legacy support

The CoreMetadataAdapter originally did not support Modern->Legacy
conversion because of the legacy use of an array ( [] ) of CoreMetadata
objects. Without accessor methods to override there is no way to
dynamically generate information, and the only way to convert Modern
data to Legacy is pure conversion. Thus, if after conversion the Modern
CoreMetadata object is changed, the Legacy version will not reflect
those changes.

This limitation is still true, but adapter support was still added so
that extensions of SCIFIOFormatReader would have, at least, something
populated to return from the getCoreMetadata() method. But this is
hopefully just a temporary solution.

The reader accessor methods, which essentially alias to CoreMetadata
attributes, will stay synchronized as they are delegated to the SCIFIO
Reader.CoreMetadata. So they should be used whenever possible.
Added MetadataStore support to SCIFIOFormatReaders

Formats converted to SCIFIO delegators were neglecting to populate their
MetadataStores, which are still necessary for backwards compatibility
with unconverted classes.

All extensions of SCIFIOFormatReader must therefore preserve the
MetadataStore state contract established by their predecessors.

Updated current converted readers to do so.
Committing factorypath settings

These .factorypaths are used by Eclipse for sezpoz annotation
processing.