Add a read-only visitor pattern.

This includes some performance tests to compare the visitor and a
traversal. Locally, the visitor is twice as fast.

This is the most basic Visitor pattern. I've had versions that were
more generic, and performance gains vanished quickly. In particular
optionally collecting results on exit halfed the performance benefits.

If we want to factor that in, we should have an independent base class
for that.

fluent.syntax/fluent/syntax/ast.py

@@ -3,6 +3,36 @@
 import json
 
 
+class Visitor(object):
+    '''Read-only visitor pattern.
+
+    Subclass this to gather information from an AST.
+    To generally define which nodes not to descend in to, overload
+    `generic_visit`.
+    To handle specific node types, add methods like `visit_Pattern`.
+    The boolean value of the returned value determines if the visitor
+    descends into the children of the given AST node.
+    '''
+    def visit(self, value):
+        if isinstance(value, BaseNode):
+            self.visit_node(value)
+        if isinstance(value, list):
+            for node in value:
+                self.visit(node)
+
+    def visit_node(self, node):
+        nodename = type(node).__name__
+        visit = getattr(self, 'visit_{}'.format(nodename), self.generic_visit)
+        should_descend = visit(node)
+        if not should_descend:
+            return
+        for propname, propvalue in vars(node).items():
+            self.visit(propvalue)
+
+    def generic_visit(self, node):
+        return True
+
+
 def to_json(value, fn=None):
     if isinstance(value, BaseNode):
         return value.to_json(fn)