parse: Use data structure for if (now named conditional)

parse: Don't write 'argument' or 'statement' in log

parse: Log parsed arguments

parse: Use data structure for statements

parse: Replace __str__ with __repr__

parse: Use data structures for values

parse: Use Token data structure instead of tuple

log: Set log level using NEWLANG_LOG_LEVEL environment variable

log: Add and use logging module

parse: Remove shebang on parse.py ...

Bad copy paste job?

parse: Add parse_file function ...

By using this, the Parser class is temporary and all parsing state is
contained according to the call stack without any possibility of
external mutation.

parse: Put parsing state and functions in its own class

parse: Move parser state down the file

parse: Instead of parser_skip just use parser_next

parse: Handle end of file better ...

Instead of throwing an error, treat end of files as a specific type of
token that's added to the end of the tokenizer.
This also means we can always return EOF once we reach the end of the
tokens just by sticking to the last token.

parse: Make verbs optional in statements ...

When a statement contains only a subject, return the subject.
This is pointless for bare statements, but very useful for set
statements.

main: Move environment to main function

main: Dispatch verbs to objects separately ...

The existing implementation of code stores objects as a dictionary
containing a type, implementation-specific data and a list of verbs.

Unfortunately this creates a circular dependency: Verbs need to supply
all possible verbs when creating an object as a return value.

To solve this, separate the manipulations of objects from the dispatch
of verbs attached to them.

parse: Fix 'Expect to' to be 'Expected To'

main: Add way to append text

main: Pass subject to verbs

main: Namespace verbs in objects

main: Add text objects and name resolution

parse: Make symbols values case sensitive

parse: Represent values as a literal or reference ...

Instead of just passing back the token, instead decide what the value is
now and let the interpreter do something with it later.

Right now it just does the same thing it did before, but hopefully it
will turn text literals in to references to objects.

parse: Replace 'tokenizer' with 'tokenize'

parse: Make tokens case-sensitive ...

This should reduce ambiguity, especially since they read differently to
both eyes and screen readers.

main: Move parsing code to parse.py

Implement just enough parser to do a hello world

main: Add initial parser ...

This is very messy and incomplete code, but it's a start.