Basic implementation of prefetch.
constant-pool-scanner 1.0 released
@since
Nitpicking. int << int then casting to long makes me uncomfortable.
doc improvement
this check is harmful.

remoteCapability.supportsPrefetch() is there to tell us if this side can call the fetch3 on the other side. Regardless of what the other side advertised, this side has already advertised the pre-fetch capability. So if the other side holds us to it, then we must deliver.
Prefetched class needs to be delivered to the classloader that's supposed to load it.

Imagine two classloaders P and C on the other side, where C delegates some of its classloading to P. On this side we got two remote classloaders Rp and Rc representing P and C respectively.

Now, imagine our loading Cc1 from Rc. Now, Cc1 actually depends on Cp1 that's loaded by P.

As a result of fetch3, we get [(Cc1,oid_Rc),(Cp1,oid_Rp)] as a return value. If we don't tell (Cp1,oid_Rp) to Rp, then someone trying to load Cp1 independently will not benefit from this prefetching. Therefore, we need to pass them to Rp eagerly.

(We still have to keep (Cp1,oid_Rp) in Rc as well so that Rp.loadClass(Cp1) will find what class file to load by which classloader.)

Note that the code behind "channel.importedClassLoaders.get(id)" seems awefully inefficient, as it creates a proxy only to look up a key. This probably needs to be improved.
tweaking with Jesse
Merge branch 'master' into prefetch-JENKINS-15120
Renamed to avoid confusion between jarFile vs jarURL
Implemented caching&prefetching

... to the point that at least all the tests pass, so it hopefully does
no harm. I have not yet verified that it does good, nor have I verified
that this works with something real like Jenkins.

The basic idea of this change is:

 - introduce an abstraction ResourceImageRef to indirect the process
   of resolving the actual data, so that IClassLoader calls don't
   blindly send byte[].
 - There's an ResourceImageRef implementation for a file inside a jar
   file (ResourceImageInJar), which fetches a whole jar file and then
   locate a resource inside it.
 - A new subsystem (JarCache) for caching jar files sent by the other
   side, and its implementations, based on jar checksums.
 - A new subsystem (JarLoader) for computing & serving jar files
   based on their checksums.
Bug fix.

Which.jarFile() can return a class directory
parent directory needs to exist or createTempFile fails
typo
JarLoader needs to be exported for the other side to use
wrote a first test case for jar prefetching
Expanding test
using the original name allows the IDE to run a single test case
added a test that more seriously exercises the dependency analyzer
updated TODO