Determinism and pi-calculus Milner embedded $\lambda$-calculus into $\pi$-calculus, showing that the $\pi$-calculus is capable of Turing-complete, deterministic calculation. Since parallel compositions of processes in the $\pi$-calculus typically have several possible non-confluent reductions, so one can use the $\pi$-calculus to model non-deterministic concurrency.

Type systems are used to prove certain desirable behaviour of programs. For example, simply typed lambda terms always terminate to a lambda abstraction value (the calculus is strongly normalising). So it's just natural to wonder whether we can find a good type system for $\pi$-calculus such that some of its processes correspond to deterministic computations.

Is there a type system for the $\pi$-calculus probably with types for processes such that processes under certain types are always confluent? Even more, could there be certain types such that their values are processes coming from lambda expressions, e.g. encoded in one of Milner's encodings?
There are plenty such typing systems.

Most work is based on the linear/affine typing system introduced
in (1) and generalised in (2). Here are the main works on this subject.
In (3) the typing system ensures a precise match with PCF (int its call-by-name variant -- changing to call-by-value is easy).
In (4) the typing system gives a precise interpretation of the
simply typed &lambda;-calculus. (5) does the same thing for System F, (6) does the same for the &lambda;&mu;-calculus.   

The typing systems in  (3, 4, 5, 6) are precise in the sense that the inhabitants of translations of &lambda;-calculus types
"are processes coming from lambda expressions", at least up to $\simeq$ (weak typed bisimulation). More precisely, if $\alpha$ is a type in the &lambda;-calculus, and $\Gamma = x_1 : \beta_1, ..., x_n : \beta_n$ is a corresponding typing environment, then the processes $P$ that are typable
as 

$$
   \vdash P \triangleright x_1 : \overline{\langle\beta_1\rangle}, ..., x_n : \overline{\langle\beta_n\rangle}, u : (\langle\alpha\rangle)^{\uparrow}
$$

are (up to $\simeq$) the translations of &lambda;-terms $M$ with

$$
   \Gamma \vdash M : \alpha   
$$

(Here $\langle \alpha \rangle$ is the translation of a &lambda;-type $\alpha$ into &pi;-types, and 
$\overline{\tau}$ the dualisation of the &pi;-type $\tau$.) The translations
are fully abstract in the sense that

$$
M =_{\beta\eta} N 
\quad\text{iff}\quad
\langle M \rangle_u \simeq \langle N \rangle_u
$$
(Here $\langle M \rangle_u$ is the translation of $M$, located at $u$.) So the embedding is as precise as one can hope for. (NB, I'm skating over some details above, for ease of presentation.)  Note  that the systems in (3, 4, 5, 6) are closely related -- indeed they are in some sense the same system, although this viewpoint has not yet been published.

If you want a brief summary of how those typing systems ensure confluence, then it is this: they ensure that there is always at most one active output (i.e. an output not under a prefix). This is brutal/syntactic.

Session types (7, 8) can also be used for this purpose, but the
correspondence is not that precise, in parts because session
types are not as constraining as the types deriving
from (1). See (9) as an example where sessions are used to model
effects (such as state) in PCF.

Davide Sangiorgi and others have also worked on this problem,
see (10) for a summary.

Aside: as the question correctly guesses, &lambda;-calculus can be seen as an especially well-behaved form of message passing, a viewpoint  put forward 1976 in Carl Hewitt's pioneering work (11) in the  actors tradition. The typing systems above essentially constrain &pi;-calculus so only this well-behaved  message passing is typable. Coincidentally, Milner invented the &pi;-calculus in parts to give a formal model of actors. In hindsight, as (12) explains nicely, there is a small mismatch between actors and &pi;-calculi.





K. Honda, V. Vasconcelos, N. Yoshida: Secure Information Flow
as Typed Process Behaviour.
K. Honda, N. Yoshida, A uniform type structure for secure information flow.
M. Berger, K. Honda, N. Yoshida: Sequentiality and the Pi-Calculus
N. Yoshida, K. Honda, M. Berger: Strong Normalisation in the Pi-Calculus
M. Berger, K. Honda, N. Yoshida: Genericity and the Pi-Calculus
K. Honda, N. Yoshida, M. Berger: Control in the Pi-Calculus
K. Takeuchi, K. Honda, M. Kubo, An Interaction-based Language and its Typing System.
K. Honda, V. T. Vasconcelos, M. Kubo, Language Primitives and Type Disciplines for Structured Communication-based Programming.
D. Orchard, N. Yoshida, Effects as sessions, sessions as effects.
D. Sangiorgi, D. Walker:  The &pi;-Calculus: A Theory of Mobile Processes 
C. Hewitt, Viewing Control Structures as Patterns of Passing Messages.
S. Fowler, S. Lindley, P. Wadler, Mixing Metaphors: Actors as Channels and Channels as Actors.