(note: when I say "the transform function" I'm referring to the function that the user passes to map, not the `_transform` function of the stream)

@mohit's test cases are failing without the setImmediate in the async case because the transform function that he passes to map actually calls the callback synchronously.

If we don't use setImmediate, we're the ones now releasing the Zalgo because whether or not that code is executed synchronously or asynchronously depends on the function that you pass in, instead of being guaranteed by the API.

We can fix this by either using setImmediate all the time (even though it's only necessary when the "asynchronous" transform function that is passed to map calls its callback synchronously) or by detecting if the transform function calls its callback synchronously or asynchronously and then only using setImmediate when necessary.

If we want to detect whether or not we need setImmediate, there's a pattern for detecting if a function calls its callback synchronously or asynchronously. Used here, that would look something like this:

```coffee
if @options._async
  sync = true
  @options.fn chunk, (err, result) =>
    switch sync
      when true
        return setImmediate cb, err if err?
        setImmediate cb, null, result
      else
        return cb err if err?
        cb null, result
  sync = false
```

The reason this works is because, if the transform function has yielded to the event loop, the `sync = false` code will have been executed when the callback is called and sync will be false. If the transform function has not yielded to the event loop, sync will not be set to false until after the callback is called.

Alternatively, you could just use setImmediate all the time