After moving an object, it must be destructable:
T obj;
func(std::move(obj));
// don't use obj and let it be destroyed as normal
But what else can be done with obj? Could you move another object into it?
T obj;
func(std::move(obj));
obj = std::move(other);
Does this depend on the exact type? (E.g. std::vector could make specific guarantees you can't rely on for all T.) Is it required or even sane that all types support something besides destruction on moved-from objects?
That's type semantics. You decide. It's up to you how you implement the move.
In general, the state should be the same as the one gained by using non-parametric constructor.
Btw. move makes only sense if you are storing a data block behind a pointer (or some other movable class).
The current draft of C++0x requires that a moved-from object can be destroyed or assigned to. If you pass your object to a function in the standard library then that is all that is assumed.
It is generally considered good practice to ensure that a moved-from object is a "working" object of its type that satisfies all invariants. However, it is in an unspecified state --- if it is a container, you don't know how many elements it has, or what they are, but you should be able to call size() and empty(), and query it.
The current draft is unclear on what is required of the standard library types themselves, and there is active discussion in the C++ committee about that.
As I finally understood from the comments. You should check this: http://www.boost.org/doc/libs/1_44_0/libs/concept_check/concept_check.htm
This will allow you to check the type supplied as template parameters for concepts (features of the type). I'm not sure if they already have one for movable.