x being of type T usually is used to describe syntax, while claiming that x is in set S is usually used to indicate a semantic property. I will give some examples to clarify this difference in usage of types and sets. For the difference in what types and sets actually are, I refer to Andrej Bauer's answer.
An example
To clarify this distinction, I will use the example given in Herman Geuvers' lecture notes. First, we look at an example of inhabiting a type:
3 + ( 7 ∗ 8 )5 5: N a t ,
3 ∈ { n ∈ N ∣ ∀ x , y, z∈ N+( xnorte+ ynorte≠ znorte) }
The main difference here is that to test whether the first expression is a natural number, we don't have to compute some semantic meaning, we merely have to 'read off' the fact that all literals are of type Nat and that all operators are closed on the type Nat.
However, for the second example of the set, we have to determine the semantic meaning of the 3 in the context of the set. For this particular set, this is quite hard: the membership of 3 for this set is equivalent to proving Fermat's last theorem! Do note that, as stated in the notes, the distinction between syntax and semantics cannot always be drawn that clearly. (and you might even argue that even this example is unclear, as Programmer2134 mentions in the comments)
Algorithms vs Proofs
To summarize, types are often used for 'simple' claims on the syntax of some expression, such that membership of a type can be checked by an algorithm, while to test membership of a set, we would in usually require a proof.
To see why this distinction is useful, consider a compiler of a typed programming language. If this compiler has to create a formal proof to 'check types', the compiler is asked to do an almost impossible task (automated theorem proving is, in general, hard). If on the other hand the compiler can simply run an (efficient) algorithm to check the types, then it can realistically perform the task.
A motivation for a strict(er) interpretation
There are multiple interpretations of the semantic meaning of sets and types. While under the distinction made here extensional types and types with undecidable type-checking (such as those used in NuPRL, as mentioned in the comments) would not be 'types', others are of course free to call them as such (just as free as they are as to call them something else, as long as their definitions fit).
Sin embargo, nosotros (Herman Geuvers y yo) preferimos no tirar esta interpretación por la ventana, por lo que yo (no Herman, aunque podría estar de acuerdo) tenemos la siguiente motivación:
En primer lugar, la intención de esta interpretación no está muy lejos de la de Andrej Bauer. La intención de una sintaxis generalmente es describir cómo construir algo y generalmente es útil tener un algoritmo para construirlo. Además, las características de un conjunto generalmente solo se necesitan cuando queremos una descripción semántica, para lo cual se permite la indecidibilidad.
So, the advantage of our more stricter description is to keep the separation simpler, to get a distinction more directly related to common practical usage. This works well, as long as you don't need or want to loosen your usage, as you would for, e.g. NuPRL.