Fixing ConcurrentModificationException when running cucumber tests in parallel
Fixed compilation
fixed the ConcurrentModificationException in LocalizedXStream
fixed broken test
Added support for SVG images in HTML output
Transformer annotation enhancement - now it can be use to annotate other annotations
Format and delimiter annotations enhancement - same as for Transformer
Add hookpoints in Cucumber and GuiceFactory

Use case: Create a subclass of Cucumber that creates a subclass of
GuiceFactory that creates an injector that has the injector of the
application being tested as its parent.
That way:
* The application stays in control of its own lifecycle (it can create its
   own injector), but steps are still scoped by scenario.
* Step classes can get injected by dependencies from the application
* The application's injector can be created once and shared between
   multiple scenarios to improve performance
Issue #2 Ensuring features are parsed before formatters are initialised
use slashes to quote regexes so that backslashes don't have to be
escaped
removed unused captures from regexes
Android: Extract the main content CucumberInstrumentation

To simplify custom instrumentation classes inheriting from other
instrumentation base classes, basically all content of
CucumberInstrumentation is extracted to the new helper class
CucumberInstrumentationHelper.
Rename CucumberInstrumentationHelper -> CucumberInstrumentationCore
Fix for #668 - using Java reflection in ScalaDsl

The previous implementation was using Scala 2.9 reflection via
Manifest[T] to extract the function parameter types using the erasure
method (renamed to runtimeClass in Scala 2.10).

The problem with this approach is that Manifest.erasure provides the
runtime java.lang.reflect.Type, which means the type has been erased of
paramterized type info.

The ParameterInfo class relies on the ParamaterizedType information
to determine how to auto populate Step arguments of type
java.util.List<T>. When using java Lists from the Scala DSL, this logic
would fail.

As ParameterInfo's implementation is entirely based on the Java
reflection API, it makes more sense to use Java reflection in the
implementation of Scala DSL as it will be compatible with the logic in
core.

This change uses Java reflection on the Scala Function objects to
extract the ParameterizedType information, which also simplifies the
code.

The manifest is no longer used by the register method, but seems to
still be required on the function definitions by another part of the
code so these have been left in place.

The functionParams method has to filter out JVM bridge methods to ensure
the correct version of the apply() method (with type parameter
information) is captured.  Function objects only have one defined method
named apply() so taking the head of the list should always be safe.
Updating gen.scala to reflect changes in previous commit

Not sure if the code generation is still being used as the functions in
ScalaDsl seem to have diverged slightly from what this script would
generate in it's current form.

Updating it to reflect the new logic anyway in case it's still required.

Pushing this as a separate commit to allow cherry picking.
Dominic: expose current (gherkin) scenario to step definition code via ThreadLocal
Dominic: expose scenario name as part of cucumber.api.Scenario
Dominic: add scenario name to test stub
Dominic: fix line number reference in test code
Merge #671. Update History.md.

Also fix file modes and remove a wildcard import.