Add notes for chapter 10 of nand2tetris.

books/nand2tetris/notes/10_compiler_i_syntax_analysis.md
	-Add all notes on chapter 10, "Compiler I: Syntax Analysis", of
	nand2tetris, which covers lexing/parsing.
Add an abstract syntax tree image to chap 10 notes.

books/nand2tetris/notes/
(10_compiler_i_syntax_analysis.md, img/abstract_syntax_tree.png)
	-Add an image of an abstract syntax tree to supplement the
	textual chapter 10 notes.
Bootstrap the Jack compiler Python package.

books/nand2tetris/projects/10_compiler_i_syntax_analysis/jack_compiler/
	-Bootstrap the Jack compiler's Python package directory
	hierarchy and touch member files.
Add a README to the Jack Compiler.

books/nand2tetris/projects/10_compiler_i_syntax_analysis/README.md
	-Add a (currently brief) README to the Jack Compiler project.

books/nand2tetris/projects/7_8_virtual_machine/README.md
	-Make a minor update to the README title for consistency with
	`10_compiler_i_syntax_analysis/README.md`.
Rename Jack compiler package/subpackages (PEP8).

10_compiler_i_syntax_analysis/((jack_compiler -> jackcompiler),
jackcompiler/(syntax_analysis -> syntax, code_generation -> compiler))
	-Rename the Jack compiler package and its subpackages for better
	compliance with PEP8 package naming standards.
Add structure to __init__, syntax/__init__.

jackcompiler/(__init__.py, syntax/__init__).py
	-Define top-level functions in each package's entry point that
	aggregate all of that package's functionality (eg, `compile()`,
	`parse()`).
	-Add documentation (docstring) comments.
Add pass-through code to parser, ast, and compiler.

jackcompiler/(compiler/__init__, syntax/(ast, parser)).py
	-Add pass-through functions to each of the above modules, since
	they're depended on by the `jackcompiler`'s sub-packages' entry
	modules (`__init__.py`) but won't be getting real
	implementations anytime soon.
WIP: commit temporary additions to modules.

jackcompiler/(__main__.py, jackcompiler/compiler/__init__.py)
	-Commit temporary additions/changes to source files (eg, basic
	command-line arguments handling to `__main__`) to facilitate
	development/debugging.
Add functional tokenizer implementation.

jackcompiler/syntax/tokenizer.py
	-Implement a functional tokenizer.
	-Define `TOKENS`, which essentially contains the Jack language
	token spec.
	-Define convenience exception `TokenizerException`, and
	implement the tokenizer itself in `tokenize()`.
Refactor tokenizer's tokenize() into two functions.

jackcompiler/syntax/tokenizer.py
	-Break apart `tokenize()` into two functions, `tokenize()` and
	`get_token()`. The former will tokenize an entire string and
	raise exceptions, while the latter is more versatile and
	extracts single tokens. Will better lend itself to unit testing.
Bootstrap the jackcompiler test package.

10_compiler_i_syntax_analysis/test/(__init__, __main__).py
	-Bootstrap the `jackcompiler` package's unit-test package,
	`test`.
	-Add an `__init__.py` with a `run_tests()` inside, which
	automagically executes all unit-test files in the package.
	Add docstrings to `run_tests()` and the module header.
Add a basic, unfinished test_syntax module.

books/nand2tetris/projects/10_compiler_i_syntax_analysis/test/test_syntax.py
	-Add a prototype of the `unittest` module for the
	`jackcompiler.syntax` subpackage.
	-Contains a `TestTokenizer` class, with one defined test
	function.
	-Minimal documentation.
Refactor test_syntax, add a Comment test case.

10_compiler_i_syntax_analysis/test/test_syntax.py
	-Refactor the `test_syntax` module, abstracting much of the code
	in `test_keyword_token()` (renamed from `test_keyword()`) into a
	generalized `_tokenize_test_cases()`, which can be reused for
	other token-type tests.
	-Define `test_comment_token()`, identical in structure to the
	current `test_keyword_token()`.
	-Add docstrings to `TestTokenizer` and all its functions.
Finish tokenizer unit tests in test_syntax.

books/nand2tetris/projects/10_compiler_i_syntax_analysis/test/test_syntax.py
	-Add functions for all remaining token-types
	(`test_symbol_token()`, `test_integer_token()`, etc.).

10_compiler_i_syntax_analysis/jackcompiler/syntax/tokenizer.py
	-Tweak `INTEGER` token-type regex.
Add a final test to TestTokenizer for tokenize().

10_compiler_i_syntax_analysis/test/test_syntax.py
	-Forgot to add a test for `tokenizer.tokenize()` in 2b3b367.
	-Define `test_tokenize()`.
Add partial Jack grammar to syntax.parser.

10_compiler_i_syntax_analysis/jackcompiler/syntax/parser.py
	-Add a partially completed Jack grammar dictionary to the
	`parser` module.
Work on the parse routine.

10_compiler_i_syntax_analysis/jackcompiler/syntax/parser.py
	-Define a partly functional parse routine, `parse_syntax()`.
	-The Jack grammar isn't fully implemented in `GRAMMAR`, or
	supported by the parser yet.
Rewrite the parser substantially.

10_compiler_i_syntax_analysis/jackcompiler/syntax/parser.py
	-Effectively rewrite the parse routine (renamed from
	`parse_syntax()` to `parse_rule()`), in an attempt to make the
	code cleaner and more readable, and it to make it more
	extendable (to allow adding infinitely nested rules, for
	instance).
Rewrite the parser again, this time for good.

10_compiler_i_syntax_analysis/jackcompiler/syntax/parser.py
	-Finish iterating on the `parser` implementation after e030860
	and 5475cd5.
	-Settle on a object-oriented approach for constructing grammar
	rules (with the `GrammarRule` class), which improves type
	handling and makes the addition of new rules cleaner and less
	error-prone.
Add documentation to the parser module.

10_compiler_i_syntax_analysis/jackcompiler/syntax/parser.py
	-Add thorough docstring to `GrammarRule`, `_add_rule()`, and the
	module header.
	-Methods of `GrammarRule` are still undocumented.