Remove legacy built-in closure implementations
Users must now register all closures they support
Remove callback for closure comparison (was never used)
Hide print_closure function
Fix symbol visibility on a number of classes
For older cmake, a second-tier test to detect if we're using clang
testshade/testrender -- fix timer call that wasn't breaking out exec time
separately from setup time.
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.
testshade: consolidate --iparam, --fparam, --vparam, --sparam ==> --param

--param takes two arguments: name and value.  For aggregates (like
colors or matrices), the value is a comma-separated list (no spaces, or
it won't recognize it as one argument).

The type is deduced from the appearance of the argument:
    1.3,0.5,0.5 is a vector
    2 is an int
    2.0 is a float (to pass an 'integer' as a float, use the decimal point)
    blah is a string (doesn't fit any other patterns)

When ambiguous -- for example, if you really want a string "14", you
can use an optional type override like this:

    --param:type=string ...

So, as an illustrative example:

OLD:
     testshade --iparam I 14 --vparam V 1 2 3 --fparam F 3 \
               --sparam Foo foo  --sparam Zero 0 ...
NEW:
     testshade --param I 14 --param V 1,2,3 --param F 3.0 \
               --param Foo foo  --param:type=string Zero 0 ...

The new code allows passing of matrix values, which the old did not
account for.

Also, the new code can allow explicit disambiguation of triple types:

      testshade --param:type=point 0,0,0 --param:type=color 0.2,0.3,0.5 ...

There's also an optional parameter that lets you specify the lockgeom
status of a parameter.  Just let that slide for now, you'll see shortly
how I'm using that (in another patch).
Add a ShadingSystem::Parameter call variety that can set lockgeom=0
on a particular parameter when the instance values are declared, even if
they were not so marked in their metadata at the time they were compiled
by oslc.

There's an interesting trick involved here: We gather pending parameters
for an instance into a ParamValueList, as a temporary holding area until
the Shader call.  We use the PV's existing 'interp' field to indicate
whether the value has a lockgeom override -- INTERP_CONSTANT as the
default, and anything else (we use INTERP_VERTEX) to mean the value may
vary across the geom, which is what lockgeom is primarily used for.
Refactor ShadingAttribState (now just use ShaderGroup / ShaderGroupRef).

In the early days, we imagined ShadingAttribState would hold several
shader groups (displacement, surface, volume, etc.) and a bunch of other
related state.  But in fact, no extra state materialized, and in practice
there was no point having the attrib state hold more than one group.

This patch refactors and simplifies to get rid of the pointless
additional abstraction layers:

* No ShadingAttribState, its usage is replaced by ShaderGroup.  It holds
  just one group, no extra state.

* Modify ShaderGroupBegin() to return the ShaderGroupRef.

* Deprecated: (1) the use of ShadingSystem::state(), not necessary with
  SGB returning the group ref; (2) the idiom of using a bare Shader()
  call to imply that it forms a group of one layer only, instead, assume
  a surrounding ShaderGroupBegin() and ShaderGroupEnd(); (3)
  ShadingSystem::clear_attribs, which was never nontrivially
  implemented.

* Improve comments in oslexec.h.
ShadingSystem::ReParameter() lets the app send a new instance param value
after the shader group has been declared, if the group has not yet been
optimized OR if the param was marked lockgeom=0.

An interesting use of this is in an interactive system that allows
adjustment of shader parameters.  If you mark the parameters that you
wish to adjust as 'lockgeom=0' (via the original Parameter declaration),
then you can use ReParameter() to replace the parameter instance value
and rerender immediately, without needing to re-declare and re-compile
the shader network.  It will not have turned the parameter value into
a constant when optimizing, since it was marked as lockgeom=0.
Bump version after recent API changes
CHANGES update
Important bug fix to recent ReParameter patch
Remove all header include guards, switch to #pragma once everywhere.
This avoids the whole issue of symbol namespace clashes with the guards.
More robust OSL_LLVM_VERSION regex to work with 3-part version numbers
Split ShaderGlobals definition into separate shaderglobals.h
Guard point transforms against possible division by 0
Create a LLVM_Util class (in llvm_util.{h,cpp}) that handles ALL direct calls
to LLVM APIs, and has NO special knowledge of OSL or its internals.

BackendLLVM (which is intimately tied to OSL) now is built on top of
LLVM_Util. Neither BackendLLVM nor the rest of liboslexec needs to directly
touch LLVM API calls and don't even need to include a single llvm header.

LLVM_Util has no dependencies on anything else in OSL (though does want
TypeDesc and ustring), and could be used as a standalone library from
other apps, to vastly simplify using LLVM to dynamically JIT code and
then execute it.  An example of this can be found in llvmutil_test.cpp.
Enable Boost Wave as the pre-processor for SPI builds
Dead code and declaration removal
Add RendererServices pointer directly to ShaderGlobals for easier access
Adjust build to account for new library names in OpenEXR 2.1.

Also had to fix a friend declaration (use the whole class name, with its namespaces, else it did not worked here [gcc4.8]).