Simplify codegen of binary ops involving closures, such as Ci = val * closure()

In OSL's ancient past, copying closures was expensive, so where possible
we tried to generate code that looked like

    result = leftoperand()
    result = result OP rightoperand()

rather than the more straightforward

    lefttmp = leftoperand()
    righttmp = rightoperand()
    result = lefttmp OP righttmp

But C (and therefore OSL) semantics dictate that the operands be fully
evaluated before the result is altered, and it turns out that we missed
detecting a couple cases where this could be violated, in particular if
the leftoperand() itself assigned to result or if rightoperand() used
the value of result (we got that right for +, but not * or /), or if the
result is a global (like Ci) in which case evaluation of leftoperand
could involve a parameter that triggers execution of an earlier layer
which itself uses or sets the same global.

But since we've long since made a closure copy merely be a pointer copy,
this is all pointless!  So greatly simplify the code while switching to
the opcode sequence that is guaranteed to be correct.
Reduce instance symbol memory use, lowering OSL-related mem by 1/2-2/3 for large scenes.

Background: The shader master (one copy for each distinct shader) holds
the full symbol table.  When a shader instance ("node/layer") is
created, it copies just the portion of this symbol table that holds the
parameters, which are the only symbols that can be overridden by the
instance, compared to the master's copy.  When the shader is optimized
and JITed, the rest of the symbol table is copied from the master, the
optimization and JIT happens, then the instance's symbol table is freed.

But, if you have enough instances, and they have enough parameters, even
just storing the parameter part of the symbol table for each instance
really adds up.  For example, a production frame I was testing had 977
shader groups consisting of a total of 280,066 instances, for which the
statistics report that OSL uses a peak of 1.4 GB (of a total RSS size of
6.1 GB).

With this patch, only a few fields in the symbol table are overridden by
the instance.  Store just those fields, then combine them with the
master's symbol table at the last moment for optimization/compile.  I
also removed a few fields and methods entirely from the Symbol class,
which were obsolete and no longer used.

Result: The test scene mentioned above improved OSL memory use from 1.4
GB peak to 590 MB peak, and reduced process RSS for the render overall
from 6.1 GB to 4.4 GB.  There is no change in runtime, this is just a
memory savings, not a time/memory tradeoff.
More instance symbol memory reduction: data field not needed, can reconstruct
with info from the master and knowledge that it was overridden (valuesource).
More instance memory reduction by freeing connection data of unused layers,
and squeezing down the size of ConnectedParam by removing an unused field
and combining two other fields into a single word using bitfields.
Merge pull request #154 from lgritz/lg-instancemem

Reduce instance symbol memory use, lowering OSL-related mem by 1/2-2/3 for large scenes
Adjust failure thresholds on some render tests to account for platform diffs
Fix oso output of matrix parameter initialization.
(1) Some combinations not output at all!
(2) Initializing to 1 set the initialization to (1,1,1,1...) instead of ident.
(3) Initializing matrices to constructed constants would emit init ops even
    when not needed.  (Fixing this may reduce init ops and improve perf
    slightly by avoiding doubly-initializing matrices.)
Interestingly, #3 largely covered up #1 and #2, by re-copying the correct
value in the process of initializing redundantly.
oslc better error checking for calling a variable as if it were a functin.
Remove reference to SVN from INSTALL
pointcloud_write