Now instead of almost every file in the top level, move the old go code
into its own directory 'golang', and the C++ code into it's own 'src'

Also removes a few obsolete scripts that were used to work on Android
before Android fully switched to Kati.

* Reduce Var instance size by moving the diagnostic message string to a
hash map for the instances that really have it (there are actually very
few such instances).
* Move common members from Var subclasses to the base class and
represent them more compactly.
* Remove RuleVar wrapper class, it is an extra object per rule-specific
variable.
* Rename Expr class to ValueList.
* Use additional constructors and convenience factory methods in Value
and its subclasses to avoid creating ValueList with a single element and
then compacting it.
* Use method overloading instead of having NewExpr2/NewExpr3, move them
for the global namespace to be factory methods of the Value class.

* Introduce SymbolSet class. As each Symbol contains sequentially
assigned ordinal value, representing a set of Symbols as a growable
bitset is faster and more space-efficient than generic unordered_bitmap
(for the full build, we save about 1500MB).
* Remove useless constructor argument.
* Make a Symbol for .KATI_READONLY constant instead of Evaluator member.
* Avoid testing 'this' for nullness in Value::DebugString, it's not
standard-compliant. Make Value::DebugString static instead.
* Avoid 'fallthrough' compiler warning.

With the introduction of deprecated / obsolete variable support, we
started calling LookupVarInLocalScope on the variable we were setting
with = or :=. This was fine, except it also marked those variables as
used environment variables (whether they were set in the environment or
not). So changing one of these environment variables would cause kati to
regenerate the ninja file even though nothing would change.

To fix this, add new Peek* functions that don't record the variables as
used, but can still be used to check to see if the variable has been
deprecated or is obsolete.

Change-Id: I62a87c5d8309b21265e904c0aeb9b3e094c9024a

When the magic variable .KATI_READONLY is set to a variable name, any
further attempts to modify the named variable will result in an error.

  FOO := bar
  .KATI_READONLY := FOO
  FOO := baz  # Error!

This is useful to make some global configuration readonly so that
another makefile cannot change it. In Android, we emulated this by
backing up some global configuration before including the Android.mk
files, then comparing the current values to the backed up values after
they've been included. But this means we don't know the location that
modified the variable, just that something did. And it's not perfect,
since the backup can also be changed.

Something similar to this could be implemented with `override`, but then
setting the variable silently fails, and it still could be overriden
with another override.

Test case:
$ cat Makefile
VAR := FAIL
$(info $(VAR))
all:
	@echo $(VAR)

$ ckati -f Makefile VAR=PASS
PASS
PASS

Was added in 29b9b7470cc33c2b7c4264f254335d788ef04c26

Regression when compared to GNU make behaviour.

Test case:

 $ cat Makefile.override-failure
 $(info VAR: '$(VAR)')
 override VAR := test
 $(info VAR: '$(VAR)')
 override VAR := test-new
 $(info VAR: '$(VAR)')
 VAR := test-should-not-work
 $(info VAR: '$(VAR)')

 $ make -f Makefile.override-failure
 VAR: ''
 VAR: 'test'
 VAR: 'test-new'
 VAR: 'test-new'
 make: *** No targets.  Stop.

 $ ckati -c --warn -f Makefile.override-failure
 VAR: ''
 VAR: 'test'
 VAR: 'test'
 VAR: 'test'
 *** No targets.

Fixes https://github.com/google/kati/issues/50

Change-Id: I9c4185c30cfcf5602da7e0ac98b7e9c420788005