Dramatically speed up LLVM optimization & JIT of small shaders.

In the process of compiling a shader group, we were handing LLVM an
buffer containing the IR bitcode for all the built-in functions that could
possibly be called.  This was a big contributing factor to compilation
overhead -- when compiling trivial shaders like
    shader constant (color Cs) { Ci = Cs*emission(); }
it was taking approximately 0.1-0.25s for LLVM optimization + JIT
(depending on the machine on which I tested).

This patch changes the strategy for feeding LLVM the bitcode, changing
from llvm::ParseBitcodeFile to llvm::getLazyBitcodeModule, which reads
just the header but deserializes the individual functions in the bitcode
lazily, if/when they are needed.  For small shaders that reference only
a tiny portion of the built-in standard library functions we supply,
this means that the vast majority are never deserialized.  On the
'constant' shader above (as measured by testshade), the LLVM
optimize+JIT time was reduced to < 0.01s!!!

I don't expect you to see a big difference when compiling huge
production shaders (maybe shave off 0.05-0.10s for each shader group,
big deal), but if you are compiling a lot of small shaders, this could
reduce the time substantially, from 200ms to perhaps just a few ms per
shader.  It's easy to imagine that this unlocks entirely new uses for
OSL as a small expression language or places where you'd frequently wish
to compile many small shaders without a noticable hiccup in your app,
which was impossible before but seems too-good-to-be-true easy with this
change.

I will backport to the recently-branched RB-1.4 if this works out, but
because it seems like black magic, I'd like to keep it just in master
for a couple weeks, until SPI has used it enough that I feel confident
in switching everybody else to it.