(SERVER-113) Move to tk-j9 webrouter service
(MAINT) Make user repl config dynamic

This commit modifies `user_repl.clj` and the sample `user.clj`
file to use a function instead of a var for the user-provided
config.

Prior to this, the config was read from disk as a var when the
REPL was first launched, and never re-loaded after that.  This
meant that doing a `reset` would not pick up changes you might
have made to the config files on disk; you needed to restart
the REPL to pick up those changes.

Now, the user config is acquired via a function call, which
means that your config files will be reloaded each time you
call `reset`.
Merge pull request #274 from cprice404/feature/master/SERVER-113-move-to-webrouter-service

(SERVER-113) Move to tk-j9 webrouter service
(MAINT) Fix bugs in webrouting config

There were a few minor issues with the default config I provided
for the webrouting service.  This commit should fix them.
(MAINT) rename jvm-puppet-conf to puppet-server-conf
Merge pull request #278 from cprice404/maint/master/fix-webrouting-bugs

(MAINT) Fix bugs in webrouting config
Merge pull request #276 from cprice404/maint/master/dynamic-user-config

(MAINT) Make user repl config dynamic
Merge pull request #277 from cprice404/feature/master/SERVER-151-flush-env-cache-from-service

(SERVER-151) Move environment fns from jruby-testutils to service
(SERVER-150) Use clojure agent to initialize jruby pool

This commit gets rid of our use of a raw `future` when priming the
JRuby pool.  Instead, we use a clojure agent.  This has the
following benefits:

* Will make it easier to re-use the pool initialization logic
* When we expose a way to request for the pool to be flushed,
  will make it possible to prevent multiple pool initializations to
  occur simultaneously
* Gives us more robust options around error handling, since we
  could now call `agent-error` on the agent instance to make
  sure that nothing has gone wrong
* Provides some scaffolding that we can re-use in order to have
  another agent handle the flushing of an existing pool
(SERVER-150) Refactor `prime-pool!` to be more re-usable

The previous implementation of `prime-pool!` required a
`PoolContext` object as input.  This meant that the
function could not be used to prime a pool that was not
yet part of a `PoolContext`.

This commit refactors the function so that it operates on
a `PoolStateContainer` instead; this will allow us to
initialize a pool before putting it into the `PoolContext`.

Conflicts:
	src/clj/puppetlabs/services/jruby/jruby_puppet_core.clj
	src/clj/puppetlabs/services/jruby/jruby_puppet_service.clj
(SERVER-150) Refactor `borrow`, et. al, to use pool directly

Prior to this commit, the `borrow-instance` and related functions
in jruby-core required you to pass a `PoolContext` object in
as input.  This prevented us from using these functions on a pool
that has not yet been added to the context.  This commit modifies
the signatures to accept the pool object directly, rather than
the `PoolContext`.

Conflicts:
	src/clj/puppetlabs/services/jruby/jruby_puppet_service.clj
(SERVER-150) Refactor `return` to not require pool

Prior to this commit, the various `return` functions that would
allow a caller to return a JRuby instance to a pool required
that you also pass in a reference to the pool that the instance
should be returned to.  This allowed the possibility of returning
an instance to a pool that it did not actually originate from.

This commit refactors the creation/borrow/return logic such that
an instance maintains a reference to the pool that it was
borrowed from, and the `return` functions use that reference
when returning the instances to a pool.  This guarantees that
instances will always be returned to the correct pool that they
were originally borrowed from.
(SERVER-150) Convert JRubyPuppetInstance to defrecord

This commit changes the JRubyPuppetInstance schema from a normal,
map-based schema to a schematized `defrecord`.  This may result
in a very minor performance improvement, but the main motivation
is to provide better compatibility with REPL-based developer
utility code.  Since we added a reference to the JRuby pool to
the schema for JRubyPuppetInstance, attempting to print the
objects results in a stack overflow, because Clojure's implementation
of `toString` for maps will recurse into these references to the
pools and attempt to print all of the instances again.

Moving to `defrecord` would allow us to override `toString` if we
wished to do so, but the default implementation of `toString` for
a record does not have the same problem with recursion that the
map objects do, so simply converting to a record solves the issue
and allows all of the utility code to be used in the REPL again.
(SERVER-150) Add service function for flushing JRuby pool

This commit adds a new service function to the JRubyPuppet service.
The new function can be used to request a flush of the JRuby pool.

The function is implemented by creating a new (offline) JRuby pool
and starting to populate it; as soon as the first instance is ready,
we can swap it into the service and remove the old pool, and then
continue initializing the remaining instances and cleaning up the
old pool in parallel.  It uses clojure agents to coordinate the
creation of the new pool and the cleanup of the old pool.