Use deferred execution for Sequence.map and Sequence.where

The methods Sequence.map and Sequence.where are now implemented using
deferred execution. They return an instance of a new Sequence-derived
class that performs the operation while iterating. This has three main
advantages:

* It can be computationally cheaper when not the whole sequence is
  iterated.

* It consumes less memory since it does not store the result in a newly
  allocated list.

* They can work on infinite sequences.

Some disadvantages are:

* Iterating the returned iterator will be slightly slower due to
  the added indirection.

* You should be aware that modifications made to the original sequence
  will affect the returned sequence.

* If you need the result in a list, you now need to call Sequence.list
  on the result.

test/core/list/map.wren

@@ -1,3 +1,3 @@
 var a = [1, 2, 3]
-var b = a.map {|x| x + 1 }
+var b = a.map {|x| x + 1 }.list
 IO.print(b) // expect: [2, 3, 4]

test/core/list/where.wren

@@ -1,6 +1,6 @@
 var a = [1, 2, 3]
-var b = a.where {|x| x > 1 }
+var b = a.where {|x| x > 1 }.list
 IO.print(b) // expect: [2, 3]
 
-var c = a.where {|x| x > 10 }
+var c = a.where {|x| x > 10 }.list
 IO.print(c) // expect: []