Add a calling convention to all function signatures.

A CallConv enum on every function signature makes it possible to
generate calls to functions with different calling conventions within
the same ISA / within a single function.

The calling conventions also serve as a way of customizing Cretonne's
behavior when embedded inside a VM. As an example, the SpiderWASM
calling convention is used to compile WebAssembly functions that run
inside the SpiderMonkey virtual machine.

All function signatures must have a calling convention at the end, so
this changes the textual IL syntax.

Before:

    sig1 = signature(i32, f64) -> f64

After

    sig1 = (i32, f64) -> f64 native
    sig2 = (i32) spiderwasm

When printing functions, the signature goes after the return types:

    function %r1() -> i32, f32 spiderwasm {
    ebb1:
        ...
    }

In the parser, this calling convention is optional and defaults to
"native". This is mostly to avoid updating all the existing test cases
under filetests/. When printing a function, the calling convention is
always included, including for "native" functions.

lib/frontend/src/lib.rs

@@ -36,7 +36,7 @@
 //! extern crate cton_frontend;
 //!
 //! use cretonne::entity_ref::EntityRef;
-//! use cretonne::ir::{FunctionName, Function, Signature, ArgumentType, InstBuilder};
+//! use cretonne::ir::{FunctionName, CallConv, Function, Signature, ArgumentType, InstBuilder};
 //! use cretonne::ir::types::*;
 //! use cton_frontend::{ILBuilder, FunctionBuilder};
 //! use cretonne::verifier::verify_function;
@@ -62,7 +62,7 @@
 //! }
 //!
 //! fn main() {
-//!     let mut sig = Signature::new();
+//!     let mut sig = Signature::new(CallConv::Native);
 //!     sig.return_types.push(ArgumentType::new(I32));
 //!     sig.argument_types.push(ArgumentType::new(I32));
 //!     let mut il_builder = ILBuilder::<Variable>::new();