Add support for standalone parallel iterators

When a forall loop is parsed, it is translated into a call to the leader and
follower iterators, approximately:

for block in iter(leader) {
  for i in iter(follower, block) {
    body;
  }
}

For standalone iterators, we don't want this nested loop.  To accomplish this,i
I added a condition with a chpl__tryToken.  Now unzippered forall loops are
built as:

if chpl__tryToken {
  for i in iter(standalone) {
    body;
  }
} else {
  for block in iter(leader) {
    for i in iter(follower, block) {
      body;
    }
  }
}

This way, if a standalone parallel iterator exists and can be used, it will be
chosen and the leader-follower case will be folded out during resolution.  If
the standalone iterator does not exist, the standalone side will be removed and
the leader-follower branch will be used.  For the most part standalone
parallel iteration is treated the same as the leader case throughout the rest
of the compiler.  One main exception is that forall intents are not yet
implemented on the standalone side.

A simple standalone iterator is defined in the test
standaloneParallelIter.chpl.  It uses a coforall to generate parallelism
and define blocks and iterates over the blocks yielding individual elements.
It also defines a leader and follower iterator to verify the standalone
iterator is chosen over them and that zippered iteration still calls the
leader/followers.  Finally it uses a for loop that results in a serial
iterator getting called.

Tested on the full suite for standard linux64
Add tag generation for the module code

Adds ctag support for chapel via the --regex and --lang[def|map] options
and uses it to generate tag files for our module code. `ctags -e` is now
used to generate the emacs format for compatibility with these options.

Also consolidated a few rules in the .gitignore for tag files, we now
generally ignore any tags or TAGS file.
Remove type declarations from Chapel tags

While it might be nice to have type declarations in the tags, we tend
to use them as variables in quite a few places and this leads to many
duplicate tags.
Add a new chpltags utility

chpltags wraps both Exuberant Ctags and etags, allowing for the creation
of both emacs and vi compatible tag files for Chapel code. This new
script is now being used to create the tag file for the modules. The
ctags.chapel file that was being used previously has been removed
Merged chapel-lang/master into standaloneParallelIterators

There were a few conflicts that needed to be cleaned up in build.cpp.
Tested with comm-gasnet.
Use the phrase "test" rather than "term" to refer to the termination test
CForLoop: Introduce initBlockGet(), testBlockGet(), incrBlockGet()
CForLoop: Migrate AstDumpToNode off cforInfoGet
CForLoop: Migrate BasicBlock off cforInfoGet
Improve the chpltags help message

Improved the chpltags help message based on feedback from
@thomasvandoren.

Added a check to ensure that a ctags executable can be found before
calling it.
CForLoop: Migrate CollapseBlocks off cforInfoGet
CForLoop: Migrate Iterator construction off cforInfoGet
CForLoop: Migrate most of the internals off cforInfoGet
Fix sub_test env var setting

If a .execenv or EXECENV file existed, subtest would copy the environment and
add whatever things were in the execenv  to it and then pass that new
environment to the test. However if sub_test set an env var after that new env
was created, that env var was not passed to the test.

This just updates how subtest adds .execenvs or EXECENV entries to the
environment. Not it just adds those to a temp list and adds that temp list to
the real environment as it's passing it to the test
Merge pull request #969 from ronawho/fix-subtest-env-var-setting

Fix sub_test env var setting

[reviewed by @thomasvandoren]

If a .execenv or EXECENV file existed, subtest would copy the environment and
add whatever things were in the execenv to it and then pass that new
environment to the test. However if sub_test set an env var after that new env
was created, that env var was not passed to the test.

This just updates how subtest adds .execenvs or EXECENV entries to the
environment. Not it just adds those to a temp list and adds that temp list to
the real environment as it's passing it to the test
Merge pull request #970 from noakesmichael/cforLoop-1

CForLoop: Introduce operators to access header info and transition most calls to BlockStmt::blockInfoGet()

Compiled: STD clang/darwin, STD gcc/linux64, LLVM gcc/linux64
Tested: paratest --verify and paratest --verify --llvm
Review: none
Skip test/io/ferguson/qio_test.test.c for Cygwin

This test depends on lseek to reset its position within a file,
and then reads a certain number of bytes to determine the file's
length.  However, on Cygwin, the use of lseek means that processes
reading text files can't depend on the number of bytes read to
determine their position within a file.  This test should be
rewritten for cygwin portability, and our qio runtime code checked
for similar assumptions.  Until then, it is not useful there.
Introduce mInitClause, mTestClause, mIncrClause and remove cforInfoGet()
CForLoop: Update loopForClause() for the new internal representation
Merge pull request #972 from noakesmichael/cforLoop-2

CForLoop: Introduce instance variables for header state and deprecate use of BlockStmt::blockInfo

This is the final step in separating the primary While/For loop nodes from a reliance on BlockStmt:blockInfo

Compiled: STD clang/darwin, STD gcc/linux64
Tested: paratest --verify
Review: none