(RangeMap) Added Range::intersect()

Returns the intersection of two ranges.

(cherry picked from edg4x branch commit 7fe9de5c0de653638efd029c80dc0a1dff23d8ac)
(Utility) Added save() and restore() to Output stream format restorer
(Binary Analysis) Added relational operators to RegisterDescriptor
(Utility) Range objects have '==' and '!=' operators now
(Binary Analysis) Able to generate generic names for missing registers

The RegisterDictionary::lookup() method could only be used to convert
a RegisterDescriptor to a name string when a register dictionary was
available, and it bailed out with an empty string if the descriptor
did not exist in the dictionary.

A new class, RegisterNames, is able to handle cases where a register
dictionary isn't available or where the dictionary doesn't contain
an entry for the specified RegisterDescriptor. Also, this class allows
customization of how the name is generated.
(Binary Analysis) A register dictionary is connected to the register state
(Binary Analysis) Semantic states can return register and memory states
(Utility) Fixed bug in Range::congruent()
(Binary Analysis) Semantic register state is fully generic

Up to this point, when one used binary instruction semantics a
particular architecture-specific register state had to be linked
into the analysis, and the only register state defined in ROSE
was RegisterStateX86, which had some problems:

  1. architecture specific
  2. missing floating-point, MMX, XMM, debug, etc. registers
  3. no support for 64-bit
  4. register names didn't reflect the size of the stored value
  5. unable to efficiently handle 8- or 16-bit code

We now have a new register state, RegisterStateGeneric.  This state
fixes all the problems above. Specifically:

  1. architecture independent since it uses RegisterDictionary
  2. stores any set of registers, even registers that don't have
     a name, like bit 1 of the x86 FLAGS register.
  3. able to store 64-bit registers and switch between 32- and
     64-bit automatically.  Code that is mostly 64-bit will run
     as efficiently as code that is mostly 32-bit.
  4. register names come from the register dictionary, therefore
     a 32-bit value stored in ax will be shown as "eax" while a
     64-bit value is shown as "rax".
  5. efficiently handles any data size by splitting and joining
     registers on demand.
(Binary Analysis) Semantics tests can use old-style output

This makes it easier to compare the output when using the
RegisterStateX86 with the output from the new RegisterStateGeneric.
(Binary Analysis) Updated answer for symbolicSemantics2

The new answer is due to using RegisterStateGeneric rather
than RegisterStateX86 and is only formatting differences and
not printing registers that were never accessed.  The latter
was tested against the RegisterStateX86 case and was identical.
(Binary Analysis) Pointer detection analysis uses register descriptor comparison operators
(Binary Analysis) Documentation for RegisterStateGeneric
(Binary Analysis) Interval, PartialSymbolic, Multi use register dictionaries
(Binary Analysis) semantics tests updated for new API
(Binary Analysis) Semantics test answers updated

Test answers changed because the semantics uses the new
generic register state.