[Tolk] Nullable types T? and null safety

This commit introduces nullable types `T?` that are
distinct from non-nullable `T`.
Example: `int?` (int or null) and `int` are different now.
Previously, `null` could be assigned to any primitive type.
Now, it can be assigned only to `T?`.

A non-null assertion operator `!` was also introduced,
similar to `!` in TypeScript and `!!` in Kotlin.

If `int?` still occupies 1 stack slot, `(int,int)?` and
other nullable tensors occupy N+1 slots, the last for
"null precedence". `v == null` actually compares that slot.
Assigning `(int,int)` to `(int,int)?` implicitly creates
a null presence slot. Assigning `null` to `(int,int)?` widens
this null value to 3 slots. This is called "type transitioning".

All stdlib functions prototypes have been updated to reflect
whether they return/accept a nullable or a strict value.

This commit also contains refactoring from `const FunctionData*`
to `FunctionPtr` and similar.

tolk-tester/tests/null-keyword.tolk

@@ -2,13 +2,13 @@ import "@stdlib/lisp-lists"
 
 @method_id(101)
 fun test1() {
-    var numbers: tuple = createEmptyList();
+    var numbers: tuple? = createEmptyList();
     numbers = listPrepend(1, numbers);
     numbers = listPrepend(2, numbers);
     numbers = listPrepend(3, numbers);
     numbers = listPrepend(4, numbers);
-    var (h: int, numbers redef) = listSplit(numbers);
-    h += listGetHead(numbers);
+    var (h: int, numbers redef) = listSplit(numbers!);
+    h += listGetHead(numbers!);
 
     _ = null;
     (_, _) = (null, null);
@@ -22,22 +22,22 @@ fun test1() {
 }
 
 @method_id(102)
-fun test2(x: int) {
+fun test2(x: int?) {
     if (null != x) {
-        var y: int = null;
+        var y: int? = null;
         if (y != null) { return 10; }
         return y;
     }
     try {
-        return x + 10;  // will throw, since not a number
+        return x! + 10;  // will throw, since not a number
     } catch {
         return -1;
     }
     return 100;
 }
 
-fun myIsNull(x: int): int {
-    return x == null ? -1 : x;
+fun myIsNull(x: int?): int {
+    return x == null ? -1 : x!;
 }
 
 @method_id(103)
@@ -64,21 +64,28 @@ fun test4(): null {
 
 @method_id(105)
 fun test5() {
-    var n: slice = getUntypedNull();
-    return !(null == n) ? n.loadInt(32) : 100;
+    var n: slice? = getUntypedNull();
+    return !(null == n) ? n!.loadInt(32) : 100;
 }
 
 @method_id(107)
 fun test7() {
-    var b = beginCell().storeMaybeRef(null);
-    var s = b.endCell().beginParse();
+    var b = beginCell().storeMaybeRef(null) as builder?;
+    var s = b!.endCell().beginParse();
     var c = s.loadMaybeRef();
     return (null == c) as int * 10 + (b != null) as int;
 }
 
+fun test8() {
+    __expect_type(null, "null");
+    __expect_type([[null]], "[[null]]");
+    __expect_type(null as tuple?, "tuple?");
+    __expect_type(null as [int]?, "[int]?");
+    __expect_type(((null)) as (int, int)?, "(int, int)?");
+}
+
 fun main() {
-    // now, the compiler doesn't optimize this at compile-time, fif codegen contains ifs
-    var i: int = null;
+    var i: int? = null;
     if (i == null) {
         return 1;
     }
@@ -120,12 +127,12 @@ fun main() {
 """
   main PROC:<{
     //
-    PUSHNULL	//  i
-    ISNULL	//  '2
-    IFJMP:<{	//
-      1 PUSHINT	//  '3=1
-    }>	//
-    10 PUSHINT	//  '4=10
+    PUSHNULL    //  i
+    ISNULL      //  '2
+    IFJMP:<{    //
+      1 PUSHINT //  '3=1
+    }>  //
+    10 PUSHINT  //  '4=10
   }>
 """
 
@@ -139,8 +146,8 @@ fun main() {
     10 MULCONST	//  b '13
     SWAP	    //  '13 b
     ISNULL	    //  '13 '14
-    NOT         // '13 '15
-    ADD	        //  '16
+    NOT         // '13 '14
+    ADD	        //  '15
   }>
 """
 */