Is there an expressiveness hierarchy for type systems? Inspired by the extensive hierarchies present in complexity theory, I wondered if such hierarchies were also present for type systems. However, the two examples I've found so far are both more like checklists (with orthogonal features) rather than hierarchies (with successively more and more expressive type systems).

The two examples I have found are the Lambda cube and the concept of k-ranked polymorphism. The first one is a checklist with three options, the second is a real hierarchy (though k-ranked for specific values of k is uncommon I believe). All other type system features I know of are mostly orthogonal.

I'm interested in these concepts because I'm designing my own language and I'm very curious how it ranks among the currently existing type systems (my type system is somewhat unconventional, as far as I know).

I realise that the concept of 'expressiveness' might be a bit vague, which may explain why type systems seem like checklists to me.
There are several senses of "expressiveness" that you might want for a type system.  


What mathematical functions can you express in a particular type system.  For example, in the simply typed lambda calculus, not all computable functions can be expressed.  The same is true of System $F$, but strictly more functions can be expressed.  This is not very interesting once you get to type systems for Turing-complete languages.
Can system $A$ typecheck every program written in system $B$.  This is basically what cody's first notion of strength is about for PTSs.  Again, System $F$ is stronger than the STLC in this ordering, since every STLC program types in System $F$.  Similarly, a system with subtyping will be stronger than a system without.
Are there local transformations (in the sense of Felleisen's paper On the expressive power of programming languages) that allow a program that types in system $A$ to type in system $B$, but not vice versa.  
Does one type system guarantee stronger properties than another.  For example, linear type systems just reject more programs, but that allows them to make stronger statements about the programs they do accept.


Unfortunately, I don't believe that there's been work on categorizing or formalizing these notions, with the exception of Barendregt's lambda-cube, as @cody discusses.