Use nextTick to avoid extremely deep stack traces

Sometimes the preprocessors and compilers call their callback
synchronously. In those cases, async.eachSeries will recurse
synchronously, and the call stack will grow very large.

Also see caolan/async#75 (comment)
and caolan/async#173 (comment).

Incidentally, this cuts initial build time in half.

lib/generator.js

@@ -110,11 +110,13 @@ Generator.prototype.preprocess = function (callback) {
     async.eachSeries(paths, function (path, pathCallback) {
       if (path.slice(-1) === '/') {
         mkdirp.sync(self.preprocessDest + '/' + path)
-        pathCallback()
+        process.nextTick(pathCallback) // async to avoid long stack traces
       } else {
         var possiblePreprocessors = [].concat(package.preprocessors, self.preprocessors)
         processFile(package.srcDir, path, possiblePreprocessors, function (err) {
-          pathCallback(err)
+          process.nextTick(function () { // async to avoid long stack traces
+            pathCallback(err)
+          })
         })
       }
     }, function (err) {
@@ -274,7 +276,9 @@ Generator.prototype.compile = function (callback) {
   this.compileDest = mktemp.createDirSync(this.dest + '/compile_dest-XXXXXX.tmp')
   async.eachSeries(self.compilers, function (compiler, callback) {
     compiler.run(self.preprocessDest, self.compileDest, function (err) {
-      callback(err)
+      process.nextTick(function () { // async to avoid long stack traces
+        callback(err)
+      })
     })
   }, function (err) {
     callback(err)