Keep in mind that existential and universal types are rather different.
It is constructive logic, not classical logic and
in constructive logic $\forall$ and $\exists$ are not as related as
they are in classical logic.
$\forall x:A. B(x)$ is the type of programs that receive an object of type $A$ and return an object of type $B(x)$.
The important thing here is that the type $B(x)$ depends on $x$ and
is not the same for all $x$.
It can vary depending on what $x$ is.
For one input $x$ we might output an integer.
For another one we might output a real number.
For yet another one we might output a function over real numbers.
If $B(x)$ doesn't vary with $x$ then you can use $A\to B$ in place
which is the type of functions from $A$ to $B$.
$\exists x:A. B(x)$ is the dependent version of (constructive) disjunction.
You can think of constructive disjunction $A \lor B$ of two types $A$ and $B$ as
the disjoint union of $A$ and $B$.
$\exists x:A.B(x)$ is the disjoint union of a collection of types $B(x)$
indexed by $x:A$.
The fact that the type $B(x)$ van vary depending on the value of $x:A$
makes it a dependent type.
Compare with the case where $B$ does not depend on $x:A$: $\exists x:A. B$.
We are taking one copy of the same $B$ for each $x:A$.
This is isomorphic to $A \times B$.
Now you can ask why we need dependent product and sum types?
Because they give us more expressive power.
Now we can ignore the types completely and
have untyped type theory/functional programming.
But that removes the benefits of having types in the first place,
e.g. you will not know if all programs will always terminate
See Lambda Cube and
I think a good way to understand dependent types well is
to look at the rules for introducing and eliminating the dependent types
in Martin-Lof's type theory.
The main point of dependent types is:
we want to remain inside a nice typed theory for various reason
(e.g. avoiding bugs, automatic proof of termination, etc.).
We don't want to go to something like untyped lambda calculus where
we can make expressing like those you stated and
way more powerful stuff.
We can say that dependent types were invented to allow expressing more things
while still remaining inside a nice type theory.