Added legacy adapter interfaces/abstract classes

Introduces the loci.legacy.adapter package, which contains the classes
that any adapter between SCIFIO and legacy classes will implement or
extend.

Adapters are intended to be bi-directional: intelligently
wrapping/unwrapping to provide the appropriate class, as desired.
Added adapters for loci-common interfaces

To preserve backwards compatibility, loci.common interfaces can not
extend ome.scifio interfaces, as method signatures in ome.scifio may
require ome.scifio parameters (while downstream code is still trying to
pass loci.common arguments).

As interfaces can not contain implementation, the solution is to keep
the loci.common interfaces unchanged, but implement a series of
adapter classes which can manage translation from a loci.common to
ome.scifio interface, and vice versa.

Thus legacy code will be preserved, but to use the latest scifio classes
code changes introducing the adapters (or directly coding against
ome.scifio) will be necessary for these interfaces and their
implementations.
Added static AdapterTools utility

All adapters maintain a mapping between legacy and modern classes. To
avoid duplication of these classes, and thus the maps (which would not
necessarily be synchronized) it makes sense to have a single active
instance of each adapter. These instances can then be accessed via a
single static entry point.

AdapterTools serves as that entry point. It uses a static initializer to
populate its mapping of adapter classes to adapter instances, and
getAdapter(Clas<Adapter>) to query into that mapping.

Note that future adapters must be manually added to the static
initializer, or adapters need to be converted to some mechanism of
discovery.
Added adapter calls to legacy layer

All legacy classes that needed to convert from loci.common classes to
ome.scifio classes now make the proper AdapterTools invocations.
Fixed return type on ServiceFactory

common.services.ServiceFactory now returns a
loci.common.services.Service instead of ome.scifio.services.

To accomplish this for now the Service interface has to directly extend
ome.scifio.services.Service.

This is not ideal (see legacy adapter package) but seems to be necessary
because of the class checking performed in ServiceFactory.
Added Object delegation to all loci-legacy classes

To ensure proper functionality, all loci-legacy classes now delegate
down to Object mehtods.
Added OMENotesService extension

loci.common.services.OMENotesService now extends both
loci.common.services.Service and ome.scifio.services.OMENotesService to
ensure that it is valid in both SCIFIO and legacy contexts.
Updated build commands for loci-legacy
Duplicate loci-legacy tests from scifio-devel

As loci-legacy currently mirrors scifio-devel, all the tests from
scifio-devel are appropriate to run from loci-legacy (under the correct
packages).

These tests should simply delegate to the scifio-devel classes, and will
help to ensure backwards compatibility.
DependencyException now extends instead of wraps

The loci.common.serivces DependencyException now extends its target.
Updated throw statements as appropriate.
Added necessary jars to SCIFIO build.properties

Several targets in the SCIFIO build.properties were missing necessary
jars (e.g. for logging, or for scifio-devel/loci-legacy dependencies)
Fixed ant test targets

The SCIFIO, SCIFIO-devel and Loci-legacy components all had ant test
targets pointing to "component.test".

Instead, the correct pattern is to define a "test" target in each
component's build.xml and invoke that from the top-level ant target.

The "test" targets were already defined but never correctly invoked.
This has been fixed.
Fixed loci-legacy test targets

The loci-legacy tests now correctly mimic the original loci-common tests
- using the testng template defined.

Previously they were incorrectly mimicing the scifio style of tests.
Refactored common->legacy .xml/properties

As the common component no longer exists, the associated .xml and
.properties files in the toplevel ant directory have been renamed
"legacy.xml" and "legacy.properties"
Updated scifio-devel unit tests

Added the appropriate test target and properties to build.xml and
build.properties respectively.

Updated loci.common -> ome.scifio packages for tests in
testng-template.xml
Location bug fixes

Fixed two issues in loci-legacy:loci.common.Location

One constructor wasn't properly instantiating its delegation target.

Added a null check to the listFiles() method.
Added surefire configuration to poms

The loci-legacy and corresponding scifio-devel pom.xml files were
lacking configuration of the maven surefire plugin for testing.

This configuration has been fixed, pointing to the appropriate
testng-template.xml
Removed protected delegation from Abstract layer

AbstractNIOHandle and AbstractService no longer delegate their protected
method functionality.

This is a tradeoff of code duplication and backwards compatibility. If
there was a downstream extension of loci.common AbstractNIOHandle, for
example, that did not have a corresponding ome.scifio version, it would
not be able to instantiate the ome.scifio AbstractNIOHandle for
delegation and thus the protected methods would be inaccessible.
Removed ome.scifio.services package

All functionality in the ome.scifio.services package will remain in
loci-legacy.

There are no services implementations within the loci-legacy package
itself, so no implementation has been converted to an ome.scifio
package, so there is nothing to delegate to in terms of concrete
implementation.

Thus instead of introducing unnecessary complexity, the implementation
will remain intact.

When a loci.formats service implementation is converted to scifio, a new
methodology (using sezpoz) will be employed, so any delegation can occur
at that time.
Specified surefire plugin configuration in scifio

The SCIFIO pom.xml now specifies its surefire plugin configuration,
specifically the testng.xml to use. This ensures the missing library
tests will all pass in the maven tests.