Make use of fetch_multi also for targets.

Should partily fix #53, though not yet optimal (cause parser still stays same)

It should be better, then previous one.
Could you check if this modification introduces no regression, while correcting the problem I mentioned (Double fetch in case of wildcards) ?

The approach is to return a dict instead of a list, the index being the original pathExpression.

I check with both fetch_multi and classical fetch.

```
diff --git a/graphite_api/app.py b/graphite_api/app.py
index 5cff247..1a81e4f 100644
--- a/graphite_api/app.py
+++ b/graphite_api/app.py
@@ -511,12 +511,12 @@ def evaluateTokens(requestContext, tokensList):
     for tokens in tokensList:
         findPaths(requestContext, tokens, fetch)

-    timeSeriesList = fetchDataMulti(requestContext, list(fetch))
+    timeSeriesDict = fetchDataMulti(requestContext, list(fetch))
     series = []
     for tokens in tokensList:
         serie = evaluateTokensWithTimeSeries(requestContext,
                                              tokens,
-                                             timeSeriesList)
+                                             timeSeriesDict)
         if isinstance(serie, TimeSeries):
             series.append(serie)
         elif serie:
@@ -525,23 +525,23 @@ def evaluateTokens(requestContext, tokensList):
     return series


-def evaluateTokensWithTimeSeries(requestContext, tokens, timeSeriesList):
+def evaluateTokensWithTimeSeries(requestContext, tokens, timeSeriesDict):
     """
     evaluate all expressions and functions.
-    Use timeSeriesList when it's needed to fetch the data
+    Use timeSeriesDict when it's needed to fetch the data
     """
     if tokens.expression:
         return evaluateTokensWithTimeSeries(requestContext,
                                             tokens.expression,
-                                            timeSeriesList)
+                                            timeSeriesDict)

     elif tokens.pathExpression:
-        for ts in timeSeriesList:
-            if ts.name == tokens.pathExpression:
-                return [ts]
-        fetch = fetchDataMulti(requestContext, [tokens.pathExpression])
-        if isinstance(fetch, list):
-            return fetch
+        if tokens.pathExpression in timeSeriesDict:
+            return timeSeriesDict[tokens.pathExpression]
+        fetchDict = fetchDataMulti(requestContext, [tokens.pathExpression])
+        fetch = []
+        for path in fetchDict:
+            fetch.append(fetchDict[path])
         return [fetch]

     elif tokens.call:
@@ -549,12 +549,12 @@ def evaluateTokensWithTimeSeries(requestContext, tokens, timeSeriesList):
         func = app.functions[tokens.call.funcname]
         args = [evaluateTokensWithTimeSeries(requestContext,
                                              arg,
-                                             timeSeriesList)
+                                             timeSeriesDict)
                 for arg in tokens.call.args]
         kwargs = dict([(kwarg.argname,
                         evaluateTokensWithTimeSeries(requestContext,
                                                      kwarg.args[0],
-                                                     timeSeriesList))
+                                                     timeSeriesDict))
                        for kwarg in tokens.call.kwargs])

         return func(requestContext, *args, **kwargs)
diff --git a/graphite_api/render/datalib.py b/graphite_api/render/datalib.py
index 8e9e0d8..b127a20 100644
--- a/graphite_api/render/datalib.py
+++ b/graphite_api/render/datalib.py
@@ -83,10 +83,12 @@ def fetchDataMulti(requestContext, pathExpr):
     from ..app import app

     seriesList = []
+    seriesDict = defaultdict(list)
     startTime = int(epoch(requestContext['startTime']))
     endTime = int(epoch(requestContext['endTime']))

     multi_nodes = defaultdict(list)
+    nodes_mapping = dict()
     single_nodes = []
     for path in pathExpr:
         matching_nodes = app.store.find(path, startTime, endTime)
@@ -95,6 +97,7 @@ def fetchDataMulti(requestContext, pathExpr):
                 multi_nodes[node.__fetch_multi__].append(node)
             else:
                 single_nodes.append(node)
+            nodes_mapping[node.path] = path

     fetches = [
         (node, node.fetch(startTime, endTime)) for node in single_nodes]
@@ -149,7 +152,11 @@ def fetchDataMulti(requestContext, pathExpr):
         for series in empty_duplicates:
             seriesList.remove(series)

-    return seriesList
+    for series in seriesList:
+        original_path = nodes_mapping[series.name]
+        seriesDict[original_path].append(series)
+
+    return seriesDict


 def nonempty(series):
```