Added support for "--python-flag=-v" to trace imports.
Added portable support for Python3 and detach "freezing" from portable mode.

* Using freezing and using portable mode are intended to become two
  different things. In fact, on Windows, the freezing may not be
  necessary on Python2 unless unusual constants are used.

* Changes to make Python3 freezing work, also preserve the existing
  entries to the freeze table. Needed for Python3, where importlib
  is frozen and needed for anything to work.
Portable mode improvements

* For Python3, it is essential to preserve the pre-existing frozen modules,
  as they contain importlib, which must be loadable or else CPython won't
  properly initialize.

* For Python3, we need to list the modules to freeze ourselves, which we
  now do in a format similar to what Python2 gave use. We also compile the
  modules to freeze ourselves.

* Whitelist even more modules used but not found by "site" module.
Added g++-4.8 to list of compiler to pick up in absence of g++.
Cleanup, use "const_" as prefix for constants to make it more clear.
Cleanup, use variable object for code names of local and parameter variables.

* Moved the encoding of non-ascii identifer names to "getCodeName" which is
  where it belongs.

* Use "par_" for parameter variables and "var_" for other local variables, it
  is more concise.
Cleanup, remove unused code for parameter variables with no "del".
Cleanup, remove special identifier classes for local and parameter variables.

* This should be handled in VariableCodes instead.
Cleanup, don't use environment variable for passing C++ header locations.
Cleanup closure and temp variable identifier code.
Cleanup, handle line number code in a central location, producing less updates.

* This makes 10% less "setLineNUmber" calls on the current frame, most
  of which will be optimized away by the compiler, but put a burden on
  the compiler that is not necessary.

* Avoids updates of line numbers inside expressions where they are not
  really necessary. These had hurt readability.

* Doing it in one central place also makes sure we know what we are
  doing there.
Optimization: Mark statement frames up if they need to restore exceptions

* This avoids a boolean flag, and checking it for the common case, which
  the C++ compiler does not optimize away.

* Gains 2.5% for pystone.

* Not done for Python3 generators yet, where it would also make a
  difference.
Cleanups
Added define to force inlining, currently only for testing purposes.

Generally forcing inlining is a bad idea, given that the C++ compiler
will know better. But in order to judge impacts of changes, it can be
helpful to eliminate inline vs. non-inline decision changes from
obscuring the generally beneficial effect of a change.
Cleanup, use dedicated class for temporary variables with "del".

* Using "None" was causing reference counters to be off by one, until
  the end of the function.

* Might be slightly more optimal code. And we are going to need that
  distinction later anyway.

* Similar trick was already applied to parameter variables.
Optimization: Remove "__dict__" and "__class__" special cases from attribute get/set paths

* The checks against the special cases were conducted at run time and
  costed each time, although the attribute name is constant and known
  at compile time.

* The call to "__getattr__" and "__setattr__" was using slow call paths
  and now should be way faster. This only applies to classes with them
  defined.

* The quicker attribute handling gives 0.5% gain for pystone.
Optimization: Remove unused m_dict and m_module from compiled methods.

* Initially it was not yet clear, if method objects should not allow
  arbitrary assignments, but that is not the case.

* The module for the compiled method was copied from the function, but
  never used.

* This gives 0.5% gain to PyStone.
Optimization: Faster code for accessing module variables and maybe module variables

* The dedicated classes were causing code bloat and couldn't avoid to
  have overhead.

* This should make compilation of modules and programs with very many
  module variables much more efficient.

* Speed gain is about 0.15% for PyStone, the benefit of this change is
  more in reduced code complexity.

* Also moved module and function related codes to dedicated modules as
  a cleanup.
Changelog updates
Optimization: Faster setting of integer constant value list subscripts

* A similar optimization already existed for look-ups and is very
  effective, because it avoids going through generic code and the
  conversion of the index value at run time.

* Gives 0.6% speed gain for PyStone.