What are some concrete examples of what typed lambda constants are?
With the simply-typed lambda calculus, constants are typically basic datatypes. For example, here is a way to encode booleans in this presentation's notation:
$$
\Sigma_B = \{ \mathrm{false} : \mathsf{bool}, \mathrm{true} : \mathsf{bool} \} \cup
           \bigcup_{T:\mathit{Type}} \big\{ \mathrm{if}_T : \mathsf{bool} \rightarrow T \rightarrow T \rightarrow T \big\}
$$
Note that we can't have a single “if” function: there needs to be one per type. To have a single “if” function that works with multiple types, you'd need to switch from the simply-typed lambda calculus to a typed lambda calculus with polymorphism. In the simply-typed lambda calculus, you have separate functions $\mathrm{if}_{\mathsf{bool}}$, $\mathrm{if}_{\mathsf{bool}\rightarrow\mathsf{bool}}$, etc.

The intended execution rules for these constants are
$$
\begin{align}
\mathrm{if}_T \: \mathrm{true} \: M \: N &amp;\longrightarrow M \\
\mathrm{if}_T \: \mathrm{false} \: M \: N &amp;\longrightarrow N \\
\end{align}
$$
But the choice of reduction rules doesn't affect the type theory. (We normally do want them to preserve types, i.e. the subject reduction property.)

For the type $\mathsf{bool}$, the constants $\mathrm{true}$ and $\mathrm{false}$ are known as constructors: they're ways to build new values of this type. The constants $\mathrm{if}_T$ are destructors: they're ways to take a value of this type and analyze it. Intuitively speaking, whenever a type is a ”data type”, it's defined by its constructors and destructors. An example of a kind of type that isn't a data type is function types, but even there you can think of lambda abstraction as a constructor for function types and application as a destructor. Constructors and destructors are a computational notion, not directly related to typing. (They do get related once you start viewing computation as a way to simplify typing proofs.)

Here's a second example with an encoding of signed integers ($\mathbb{Z}$). Note that this is just one possible encoding, a simple one from the typing perspective.
$$
\Sigma_N = \{ \mathrm{0} : \mathsf{int}, \mathrm{S} : \mathsf{int} \rightarrow \mathsf{int}, \mathrm{P} : \mathsf{int} \rightarrow \mathsf{int} \}
$$
This particular signature defines three constructors: $\mathrm{0}$ (zero), $\mathrm{S}$ (successor) and  $\mathrm{P}$ (predecessor).
You may want to combine booleans and integers. For typing purposes you can just put them together, but for computational purposes it's useful to add a way to destruct an integer, e.g. by adding a comparison function. Here I've made the comparison function piggyback on booleans so that it doesn't need to be polymorphic.
$$
\Sigma_{BN} = \Sigma_B \cup \Sigma{N} \cup \{\mathrm{le} : \mathsf{int} \rightarrow \mathsf{int} \rightarrow \mathsf{bool} \}
$$