Give a cppia member field declared Bool its boolean storage

[MeguminBOT]

The problem

A class member declared Bool in a cppia module gets an integer slot, so reading it back through
reflection gives you 1 instead of true. A static field of the same declared type, in the same
module, gives you true:

member 1, static true

Conditions and comparisons still work, since they are happy with the integer. Anything that looks at
the value itself does not.

Why

CppiaVar::linkVarTypes has two forms:

• The static form calls fieldStorageFromType, which has a case for Bool and returns fsBool.
• The member form switches on exprType instead. By the time it runs, TypeData::link has
  already mapped the Bool type name to etInt, so the field ends up as fsInt.

That is why the two fields above disagree.

The fix

In src/hx/cppia/CppiaVars.cpp, the member form now calls fieldStorageFromType too:

storeType = typeId==0 ? fsObject : fieldStorageFromType(type);

switch(storeType)
{
   case fsBool: ioOffset += sizeof(int); break;
   case fsByte: ioOffset += sizeof(int); break;
   case fsInt: ioOffset += sizeof(int); break;
   case fsFloat: ioOffset += sizeof(Float); break;
   case fsString: ioOffset += sizeof(String); break;
   case fsObject: ioOffset += sizeof(hx::Object *); break;
   case fsUnknown:
      break;
}

The slot is still int sized, so the layout and the AlignOffset call above it do not change.

Test

test/cppia covers it. ClientBoolField in Client.hx holds a Bool member and a Bool static,
and testBoolMemberStorage in cases/TestCommon.hx reads both back through Reflect.field.

cd test/cppia
haxe compile-host.hxml
haxe compile-client.hxml
cd bin && ./CppiaHost.exe client.cppia

Without the fix that test fails with Member Bool did not read back as a boolean, and the static
assertion beside it still passes, which is the pair that shows the two forms disagreeing. Same result
with or without -jit.

Reproducing by hand

Script.hx, built with haxe -m Script --cppia script.cppia:

class Holder {
   public var flag:Bool = true;
   public static var staticFlag:Bool = true;
   public function new() {}
}

class Script {
   public static function run():String {
      return 'member ' + Std.string(Reflect.field(new Holder(), 'flag'))
         + ', static ' + Std.string(Reflect.field(Holder, 'staticFlag'));
   }

   public static function main():Void {}
}

Load it from a host built with -D scriptable, using
cpp.cppia.Module.fromData(bytes).boot(), and call Script.run through reflection.

	result
before	member 1, static true
after	member true, static true

Same result with the JIT on or off, since the storage is decided at link time.

Let me know if I got anything wrong!