fallout from review

https://github.com/openSUSE/libstorage/pull/73#issuecomment-48320644

this reverts `auto` declarators used in ranged-for statements
to explicit typenames, with the exception of statements where
the iterated range is:

* a local variable declared with an explicit type
* a member variable declared in the same class (not inherited)
* result of a method defined in the same class (not inherited)
* result of a free function defined in the same source file

local variables
===============

  void op(vector<int> const &offsets)
  {
  list<string> labels;
  // ...
  for (auto const &i : offsets) // no need to repeat `int`
    use(i);
  // ...
  for (auto const &i : labels) // no need to repeat `string`
    use(i);
  }

data members declared in the same class
=======================================

  struct fubar : snafu
  {
    vector<int> offsets;
    // ...
    void op()
    {
      for (auto i : offsets)
        use(i);
    }
  }

methods declared in the same class
==================================

  struct fubar : snafu
  {
    vector<int> offsets();
    // ...
    void op()
    {
      for (auto i : offsets())
        use(i);
    }
  }

free functions defined in the same source file
==============================================

  vector<int> offsets()
  {
    // ...
  }
  // ...
  struct fubar : snafu
  {
    void op()
    {
      for (auto i : offsets())
        use(i);
    }
  }

i posit that there's no loss of information in going from
`for (PeMap::const_iterator it = x.begin(); ...)` and its ilk
to `for (auto const &it : x)`, (PeMap is *obviously* a typedef
for `std::map<string, unsigned long>`, right?

j/k, it's not, and the fact that `PeMap::const_iterator` was ok
while `auto` is not suggests that the stated reason for pushback
against `auto` ("I dislike [auto] since it makes it more difficult
for the user to determine the type upon inspection") is not the
whole story. :)

notice that the value of decltype(i)::value_type (it's Volume)
is mentioned nowhere in

  bool Volume::loopInUse(const Storage* sto, const string& loopdev)
  {
    bool ret = false;

    Storage::ConstVolPair p = sto->volPair(hasLoopDevice);
    Storage::ConstVolIterator i = p.begin();

    while (!ret && i != p.end()) {
      ret = i->loop_dev == loopdev;
      ++i;
    }
    return ret;
  }

IMO, if ConstVolIterator is good enough to confer that the type
of `i` is Volume, so is volPair():

    // 1.
    Storage::ConstVolPair p = sto->volPair(hasLoopDevice);
    for (Storage::ConstVolIterator i = p.begin(); i != p.end() ++i) {
      ret = i->loop_dev == loopdev;
      if (ret) break;
    }

    // 2.
    Storage::ConstVolPair p = sto->volPair(hasLoopDevice);
    for (auto i = p.begin(); i != p.end() ++i) {
      ret = i->loop_dev == loopdev;
      if (ret) break;
    }

    // 3.
    for (auto const &i : sto->volPair(hasLoopDevice)) {
      ret = i.loop_dev == loopdev;
      if (ret) break;
    }
cleanup: needless variables, stuttering type names