Switch interpreter to use IValue's primitive int/floats (#9584)

[zdevito]

Summary:
This patch switches the interpreter to use IValue's primitive numbers rather than tensors for computing on integers and floats. In addition to preparing the interpreter for first-class support of other types, this cleans up the handling of primitive numbers, making it possible to just use the normal operator overloading dispatch to find the right implementation for numbers. As a result of this change, a lot of other functionality needed to be updated since it was the first time we use non-tensors in a lot of places in the code base.

Notes:

• Fixes code_template.py so that multi-line strings are indented correctly when used on a standalone line
• Cast operators (int(x)) now are functional. Some tests have addition conversions to integers because
  we no longer allow implicit tensor -> integer conversions following the same convention as in python
• prim::ListConstruct/createList has been added to the interpreter for creating lists and this has
  replaced aten::stack for integers lists
• gen_jit_dispatch.py has been refactored so that non-tensor types use operators on IValues to extract
  the primitives
• IValue gains a .to method that is the equivalent of tensor_as but for IValue instead of at::Tensor
• constant_as<T> is switched over to using IValues's .to<T> method, to make conversion from constant->IValue->C++ type
  more consistent. This functionality combined with toIValue(Value*) replaces the tensor_as and as_tensor family of functions.
• conditional expressions (if, loop) and operators related to them are now computed on integers rather than tensors
• IValue gains constructors for constructing from at::Scalar and converting to it. However, IValue itself will always store
  the scalars as a double or int64.
• To align with python 3 syntax, TK_INT, TK_FLOAT, and TK_BOOL have been removed from the parser, and int/float/bool are just treated as special identifiers in the compiler,
  along with print. These are represented as special sugared values with a call method implemented. For int/float/bool this implements casting behavior.
• Dropped shared_from_this from Type/Module. They were not needed and they making debugging harder because they internally throw/catch exceptions.
• Shape propagation has been updated to support running nodes that include floating point primitive types, this required some refactoring of internal functions.
• TensorToNum and NumToTensor have actual implementations as operators now
• regster_prim_ops now contains implementations of math operators for float/int primitive types, and for mixed (prim <+> tensor) versions. This removes the need for special handling in compiler.cpp
• Primitive math is now entirely handled by letting the compiler choose the right overloads. This removes tons of special casing in the compiler.
• incorporates eellison's change to allow casting from return values. Due to the addition of primitive support, the code need slight modifications, so I just pre-merged it here.
• stack.h gains generic vararg versions of push/pop that know how to convert to/from C++ types:

at::Tensor a;
at::Scalar b;
pop(stack, a, b);
at::Tensor c = a + b;
push(stack, c);

apaszke
Pull Request resolved: #9584

Differential Revision: D8910546

[jamesr66a]

Looks fine assuming the windows linker error is benign/can be fixed. Let's revisit the broadcast flag in ONNX export as a follow-up