Well, Manipulate is a lexical scoping construct, like Module. Consider:

var = "global"; func[] := var; Module[{var = "local"}, func[]]

This correctly returns "global" and not "local", because the var scoped by the Module is different from any var outside the Module. See the lexical scoping docs for more information and examples.

The same goes for Manipulate. Your definition of f refers to the symbol b, but the b in the definition of f is not the same b as the b scoped by Manipulate. The definition of 'speed' doesn't refer to local Manipulate variables, so it doesn't have the scoping issues that f does.

As Simon suggested, one way to avoid this scoping problem would be to move the definition of f into the scoping construct. That works fine for Module, but can cause subtle problems for Manipulate. (For instance, if you had two copies of a Manipulate output, and each set f to be a function of local Manipulate variables, then f would be constantly redefined whenever you interact with either output.)

A solution which works better for Manipulate would be to pass local variables as arguments to your utility functions.

var = "global"; func[x_] := x; Module[{var = "local"}, func[var]]

Manipulate[

 f[t_] := E^(-a*t)*Cos[b*t];
 g[t_] := E^(-a*t)*Sin[b*t];
 c[t_] := {f[t], g[t]};

 Grid[{{Show[
     ParametricPlot[c[t], {t, 0, B}, PlotStyle -> {Thick, Blue}, 
      PerformanceGoal -> "Quality"], 
     ListPlot[{c[B]}, PlotStyle -> {Black, PointSize[0.02]}], 
     AxesLabel -> {"x", "y"}, PlotRange -> 1.2, ImageSize -> Medium, 
     AxesOrigin -> {0, 0}]}}],

 {B, 0.00001, 4 \[Pi]}, {{a, 1}, 0.1, 10}, {{b, 1}, 0.1, 10}]