Don't throw away type annotations

The expression language defines a parser

    declParser :: BlinkParser (Name, Ty, Maybe SrcExp)

but this parser is only used at the very top-level (for MkProg). Everywhere
else we use a derived parser which throws away the type annotation if there
is a source expression:

    declParser' :: BlinkParser (Name, Either Ty SrcExp)
    declParser' = do
      (x, ty, mbinit) <- declParser
        return (x, case mbinit of Nothing -> Left ty ; Just ei -> Right ei)

I discussed this with Dimitri and we decided that it would be better not to
throw away these type annotations. This however implies some AST changes.
I've pushed this all the way through, but have marked a few TODOs that somebody
who is more familiar with the compiler should take a look at.
Change top-level to be list of declarations

This updates all the examples in tests/parser but not yet the rest
(for tests/parser verified the parse trees).
Continue updating examples

Seem to have hit a snag though
Regard CPP pragma lines as part of a semi-colon

CPP pragma lines were considered whitespace previously, and accepted
everywhere. We then had a separate check that they only occurred at top-level
(we kept track of the nesting level in the parser state). However, this didn't
work quite so well anymore once we changde the top-level to be a list of
declarations, because previously we might have something like

    let x = << ... >> in

where we would have increased the nesting level in the `<< .. >>` part, and
then decrease it when seeing the `in`. However, now this looks like

    let x = << ... >>

    # 1 "filename" 2

instead, and the parser does not yet know that it should have decreased the
nesting level when seeing the CPP pragma and therefore gave an error.

Instead, we now treat the CPP pragma lines as part of the semi-colon.

NOTE: Strictly requiring pragma lines at top-level only does not work, because
it would allow something like

    fun comp f() {
    #ifdef FOO
        something
    #else
        somethingElse
    #endif
    }

because after CPP has expanded this `#ifdef` it leaves a CPP location line in
the middle of the definition of `f`.
Finish updating examples
Remove obsolete module.
Revert "Remove obsolete module."

This reverts commit 09fdc59e69bddcb3df83e3fd365d5a92368d721c.
Change treatment of CPP pragmas again

We now allow CPP pragmas everywhere but, crucially, we regard CPP pragmas as
whitespace _only_ if they don't change the filename. CPP pragmas that _do_
change the filename are accepted only as part of delimiters for the top-level
list of declarations. This means that we can now accept something like

   let comp main =
      read [int] >>>
   #ifdef FOO
      something
   #else
      somethingElse
   #endif
      >>> write [int]

which we couldn't previously because we regarded these CPP pragmas as
semi-colons. Now we can, but at the same time by allowing filename changes at
top-level only we cn detect, say, a missing curly at the end of a file; for
instance, if a.blk looks like

   fun {

and b.blk tries to #include a.blk we will now get a parser error saying:

    "./a.wpl" (line 5, column 14):
    unexpected "\n"
    Unexpected end of file (#included files must consist of a complete list of declarations)
    ExitFailure 1
Deal with type annotations in let refs

(and fix parser for let refs in expressions)
Merge branch 'feature/decls-at-toplevel' into dev

Conflicts:
	code/WiFi/receiver/cca/cca_tufv.blk
Modified bits in library to the new parser
Updated BUILD instructions
Merge branch 'release' of github.com:dimitriv/Ziria into release
Ignore trailing comma in infiles

This closes #25.
Generate ".." rather than <..> for local includes
Whitespace (separate commit)
Fix running tests/backend

See comment.
Further fix to build system
Whitespace (separate commit)
Allow int8 and int16 in for loops