Enumerating an uncountable graph 
Proposition 1.4.1. The vertices of a connected graph $G$ can always be enumerated, say as $v_{1}, \ldots, v_{n}$, so that $G_{i}:=G\left[v_{1}, \ldots, v_{i}\right]$ is connected for every $i$.
Proof. Pick any vertex as $v_{1}$, and assume inductively that $v_{1}, \ldots, v_{i}$ have been chosen for some $i<|G|$. Now pick a vertex $v \in G-G_{i}$. As $G$ is connected, it contains a $v-v_{1}$ path $P$. Choose as $v_{i+1}$ the last vertex of $P$ in $G-G_{i}$; then $v_{i+1}$ has a neighbour in $G_{i}$. The connectedness of every $G_{i}$ follows by induction on $i$.

In my interpretation, this theorem is saying that we can grow out a connected graph from an original starting position one by one. What happens if there are uncountably many nodes? Would this enumeration still be possible?
 A: Yes, but it requires the use of transfinite induction. As is usually the case, this is not hard, but requires slightly more care than induction in the finite case.
We induct up to $|G| = \eta$. Enumerate the vertices of $G$ as $\{ v_\alpha \mid \alpha < \eta \}$.
We let $G_1 = \{ v_0 \}$.
At successor stages, we define $G_{\alpha + 1}$ as follows. Since $G$ is connected, there's a path $p$ from $v_{\alpha}$ to $v_0$. Let $G_{\alpha + 1}$ be $G_\alpha$ plus all the vertices in $p$.
Notice $G_{\alpha+1}$ is connected and contains $v_{\alpha}$ (since $G_\alpha$ was connected by construction, and we added the entire path from $v_0$ to $v_\alpha$).
At limit stages, we define $G_\lambda = \bigcup_{\alpha < \lambda} G_\alpha$. This is still connected, since every $v_\beta \in G_\lambda$ must have been added in one of the stages before $\lambda$, and thus has a path to $v_0$ by induction. Also, again by induction, $G_\lambda$ contains all the vertices $v_\alpha$ with $\alpha < \lambda$.
Then this sequence of graphs $(G_\alpha)$ does what you want. If it's important that $G_{\alpha + 1}$ has exactly one more vertex than $G_\alpha$, you can modify this construction to add the path from $v_0$ to $v_\alpha$ one vertex at a time. This makes the indexing more annoying, but there's no other complications.

I hope this helps ^_^
