- Implemented array expressions
- Implemented array syntax handling in the pipelines module

The following features are now implemented

- Let is no longer a builtin command, but part of the language
  - Export has not been ported, but will surely follow shortly
- Implements ability to create arrays with command array substitutions
  - Array command substitutions currently split based on whitespaces
- For loops may operate directly on arrays
  - Was already implemented, but it's nice to see it in action
- In addition, brace expansions also create arrays
  - Because logically, each permutation is a new element
- Arrays may be accessed with the @ sigil
  - Braced Arrays aren't yet supported
- Powers (exponents) have been implemented for let arithemtic

```ion
for i in @[echo one two three]
    echo $i
end
```

```ion
let array = one-{up,down}
echo @array
```

However, much more work is to be done. Progress is bein tracked in
issue #254. Most notably, the largest missing feature is the array syntax
for manually creating new arrays.

This will implement support for brace ranges:

echo {a..z}
echo {z..a}
echo {A..Z}
echo {Z..A}
echo {1..10}
echo {10..1}
echo {-50..0}
```

This work required a lot of mental effort to complete, but the results
are more than worth it. Not only is the new code easier to read, manage,
and extend, but it is faster and provides better syntax parsing than
what we had before.

- Rewrote the 'WordIterator'
  - Reimplemented Brace Words
  - Implemented Nested Branches
  - Reimplemented Variable Words
  - Implemented Process Words
  - Reimplemented Tilde Words
  - Reimplemented Normal Words
  - Reimplemented Whitespace Words
  - Reimplemented Quote Handling
  - No more Result error checking
- Rewrote Brace Expansion
  - Implemented Nested Branches
  - Words are now properly collected before expansion
- Rewrote Variable Expansion
  - The WordIterator does all the work here
  - Module removed as it is no longer required
- Shell expansion now correctly returns a vector of strings
- Implemented an ArgumentSplitter for parsing for expressions
  - Does not yet handle parsing processes correctly
  - Shamelessly copied from my Parallel project
- Performance Improved ++

With this out of the way, I will be implementing more features on top of
this really soon. Arrays will become first class citizens soon, and the
syntax validation layer will see much more work.

Implement tilde expansion for other user's home directories.

This commit adds support only for non-Redox unix systems.

There will always be one pipeline so there is no need to use a Vec for storing the results.
This change will eliminate the pointless Vec indirection to get to the inner value.

With this change, support for multiple lines is complete

This commit message has been written with the new multi-line support that is now
implemented in the REPL. There is a new specialized QuoteTerminator structure
that provides the means to handle this by checking if the last character provided
was a '\' and trimming the next line, or keeping state of wether a single or
double quote has been terminated, and continuing to buffer until both are
properly terminated.

Each statement will now be validated for correct syntax. When an
error is found, a descriptive error will be printed to standard
error and that statement will be skipped.

The two types of errors that are curretly detected are unterminated
subshells and unescaped parenthesis in the wrong place. More types
will be added to this logic in the near future, such as unterminated
braces or invalid characters in brace logic.

This is the first step towards an upcoming brace expansion rewrite
that I am planning to perform.

This will merge the glob expansion method with the existing expansion method so that arguments will not need to be cloned twice. In addition, this will use a draining iterator in the expansion method and skip the expansion check for the first argument. The build_command method is also improved to use a draining iterator instead of checking each argmument.

This change will build the builtin map at the beginning of the program instead of building it every time a command is executed.

With this change, there should be much less memory copies as the
pipeline expansion logic has been rewritten to take mutable references
instead of creating all new `Pipeline` objects.

Pipe redirection will follow shortly

[RTM] Flow Control Rewrite

- All of the flow control logic was re-written from scratch
- If conditions are now properly and fully supported
- Else if conditions are also supported with this change
- All flow control keywords support endless nesting now
- Examples have been updated and several more were added

Implement Basic Arithmetic for Let/Export

Implement Proper While Support

Refactor Let/Alias/Export & Implement Builtin README