Fixed bug that unable call query_2 after call describe method on dynamodb2 module

This fixes the #2828 and #2708 issues.

As shown on that issue, there was a strange behaviour when calling describe method and then query_2. 

I've found out that when you create a fresh new Table instance it has not schema, indexes or even global_indexes. So when you call query_2 method is check whether you have those parameters and if you haven't it tries to perform the call as usual. 

In the other hand when you call describe method it was setting all those instance variables but self.global_indexes which was causing it to raising an exception on the following statement at the begging of query_2 method as shown below;

```Python
 if self.schema:
            if len(self.schema) == 1:
                if len(filter_kwargs) <= 1:
                    if not self.global_indexes or not len(self.global_indexes):
                        # If the schema only has one field, there's <= 1 filter
                        # param & no Global Secondary Indexes, this is user
                        # error. Bail early.
                        raise exceptions.QueryError(
                            "You must specify more than one key to filter on."
                        )
```

As Global Secondary Indexes were being sent by the DynamoDB API, all I had to do was to update the instance variable self.global_indexes with that information.  Now it's working as expected :)

I hope you find my pull request useful. If you do, please accept my pull request.

Best Regards
This method is very similar to the one above. It would be probably easier to have both of them use a map based on the project type. 

```
def _introspect_all_indexes(self, raw_indexes, map):
    """doc"""
    indexes = []
    
    for field in raw_global_indexes:
        kwargs = dict(parts=[])
        index_cl = map.get(field['Projection']['ProjectionType']) 
        if not index_cl:
            raise exceptions(...)
       
        if field['Projection']['ProjectionType'] == 'INCLUDE':
            kwargs['includes'] = field['Projection']['nonKeyAttributes']
       
        name = field['IndexName']
        kwargs['parts'] = self._introspect_schema(field['KeySchema'], None)
        indexes.append(index_klass(name, **kwargs))
return indexes
```

So: local and global can consume the same code:

```
PROJECTION_TYPE_TO_INDEX = dict(
    global={
        ALL=GlobalAllIndex,
        KEYS_ONLY=GlobalKeysOnlyIndex,
        INCLUDE=GlobalIncludeIndex),
    local=dict(
        ALL= AllIndex,
        KEYS_ONLY= KeysOnlyIndex,
        INCLUDE=IncludeIndex))

[...]

def _introspect_global_indexes(self, raw_global_indexes):
    return self._introspect_all_indexes(
        raw_global_indexes, PROJECT_TYPE_TO_INDEX.get('global'))

def _introspect_indexes(self, raw_global_indexes):
    return self._introspect_all_indexes(
        raw_global_indexes, PROJECTION_TYPE_TO_INDEX.get('local'))
```