Fluent API aka Navigator

The Navigator API is a fluent API for LevelGraph, loosely inspired by [Gremlin](http://markorodriguez.com/2011/06/15/graph-pattern-matching-with-gremlin-1-1/)
It allows to specify joins in a much more compact way and navigate between vertexes in our graph. I am including the following example in `examples/foafNavigator.js`.

With this dataset:
```
  db.put([{
    subject: "matteo",
    predicate: "friend",
    object: "daniele"
  }, {
    subject: "daniele",
    predicate: "friend",
    object: "matteo"
  }, {
    subject: "daniele",
    predicate: "friend",
    object: "marco"
  }, {
    subject: "lucio",
    predicate: "friend",
    object: "matteo"
  }, {
    subject: "lucio",
    predicate: "friend",
    object: "marco"
  }, {
    subject: "marco",
    predicate: "friend",
    object: "davide"
  });
```

Here is an example:
```
    db.nav("matteo").archIn("friend").archOut("friend").
      contexts(function(err, results) {
      // prints:
      // [ { x0: 'daniele', x1: 'marco' },
      //   { x0: 'daniele', x1: 'matteo' },
      //   { x0: 'lucio', x1: 'marco' },
      //   { x0: 'lucio', x1: 'matteo' } ]
      console.log(results);
    });
```

The above example match the same triples of:
```
    db.join([{
      subject: db.v("x0"),
      predicate: 'friend',
      object: 'matteo'
    }, {
      subject: db.v("x0"),
      predicate: 'friend',
      object: db.v("x1")
    }], function(err, results) {
      // prints:
      // [ { x0: 'daniele', x1: 'marco' },
      //   { x0: 'daniele', x1: 'matteo' },
      //   { x0: 'lucio', x1: 'marco' },
      //   { x0: 'lucio', x1: 'matteo' } ]
      console.log(results);
    });
```

It allows to see just the last reached vertex:
```
    db.nav("matteo").archIn("friend").archOut("friend").
      values(function(err, results) {
      // prints [ 'marco', 'matteo' ]
      console.log(results);
    });
```

Variable names can also be specified, like so:
```
db.nav("marco").archIn("friend").as("a").archOut("friend").archOut("friend").as("a").
      contexts(function(err, friends) {
 
  console.log(friends); // will print [{ a: "daniele" }]
});
```

Variables can also be bound to a specific value, like so:
```
db.nav("matteo").archIn("friend").bind("lucio").archOut("friend").bind("marco").
      values(function(err, friends) {
  console.log(friends); // this will print ['marco']
});
```

A materialized join can also be produced, like so:
```
db.nav("matteo").archOut("friend").bind("lucio").archOut("friend").bind("marco").
      triples({:
        materialized: {
        subject: db.v("a"),
        predicate: "friend-of-a-friend",
        object: db.v("b")
      }
    }, function(err, results) {
      
  // this will return all the 'friend of a friend triples..'
  // like so: { 
  //   subject: "lucio", 
  //   predicate: "friend-of-a-friend",
  //   object: "daniele"
  // }

  console.log(results); 
});
```

It is also possible to change the current vertex:
```
db.nav("marco").archIn("friend").as("a").go("matteo").archOut("friend").as("b").
      contexts(function(err, contexts) {

   //  contexs is: [{
   //    a: "daniele",
   //    b: "daniele"
   //   }, {
   //     a: "lucio", 
   //     b: "daniele"
   //   }]

});
```

Here are the things that I believe are missing:
* [x] specify a binding for a vertex e.g. a friend's name.
* [x] start the navigation from a variable.
* [x] specify a variable's name.
* [x] add a `contexts` and `contextsStream` methods, giving the same result as the `join`/`joinStream` API.
* [x] add a `triples`and `triplesStream` methods, in order to get a 'materialized' stream of triples coming from a join.
* [x] `go` operator, to jump to another vertex.
* [ ] An updated README.