Specs and tests run only once, but much of JRuby's logic for
optimizing code only runs after call sites have been executed more
than once. This patch adds a CI job that runs language examples
at least twice to ensure such logic is tested.

Currently this runs the specs four times, to try to ensure that
all optimizations are tested. This is based on an expectation that
most code will pass through the following stages (with JIT
threshold set to 0):

* Methods will be forced to JIT and execute their compiled form
  immediately, but blocks may delay compilation if their
  surrounding method has not yet been compiled. This first stage
  may run in the interpreter.
* Once compiled, call sites and other caches (like global vars)
  will initially be unoptimized, executing similar to the way
  the interpreter handles these constructs. This second stage
  is compiled, but unoptimized.
* After the initial encounter of a call site, the optimized code
  will be installed for future invocations. This third stage is
  now compiled and using optimized call sites.
* Some sites, such as those that redispatch for new/initialize
  or !=, may have additional caches that will not be encountered
  until the optimized code has been installed. This fourth stage
  helps ensure such multi-layer caches have optimized.

There are other cases where more than 4 runs may be necessary,
such as for polymorphic sites that must be built up across many
calls, but such cases usually will only have slight differences in
behavior from monomorphic sites (primarily around the cascading
PIC logic that searches for a matching type). Rather than attempt
to add additional runs with diminishing returns, we may explore
more repetitive runs on a narrower set of specs.

I have also included a small patch for mspec to allow using the
repeat flag in CI mode (previously it was only available for the
run command.