Enumerating weighted permutations in sorted order problem
Seems like a straightforward recursive algorithm, combined with streams (also known as lazy lists or generators), should work.  i.e.,

def subsets(m, S):
  if m==0:
      return [{}]
  if S is empty:
      return []
  s = min(S)
  S' = S \ {s}
  T = subsets(m, S')
  U = [u.union(s) for u in subsets(m-1, S')]
  return merge(T, U)


With the obvious definitions and Python-ish notation.  This returns a list in the desired order, i.e., a list of subsets, sorted by the sum of the elements in each subset.  Here I haven't provided the merge routine, but it can be implemented using the standard algorithm for merging sorted lists.

For clarity of exposition, I've written the above using lists and list comprehensions.  However, for an actual implementation, you should use streams (e.g., Python generators and generator comprehensions) rather than lists.  If you do that, there's no need to build all of the lists and represent them in memory; the algorithm shown above can proceed in a streaming fashion.

This is the kind of problem where a language with explicit support for lazy evaluation will shine.  With lazy evaluation, I believe you can implement a beautiful, elegant solution that looks clean but has excellent memory complexity.