The answer depends on the structure of the algebra.
I therefore cannot give a universal answer. Instead, I will illustrate the structural dependence by means of examples. In response to the request for implementation, they also illustrate one possible way to exploit Mathematica's support for symbolic computations. (I welcome comments suggesting clearer or more efficient approaches.)
Take, for instance, the second example of the question. Here is an abbreviated implementation of the wedge product of alternating bilinear forms, enough to get us going:
SetAttributes[Wedge, Flat];
Wedge[element[ω___], element[η___]] :=
With[{ϕ = Flatten[{ω, η}]},
signature[ϕ] (element @@ Union[ϕ])
];
Wedge /: Wedge[Times[x_, ω_element], y_] := Times[x, Wedge[ω, y]];
Wedge /: Wedge[x_, Times[y_, ω_element]] := Times[y, Wedge[x, ω]];
Wedge[ω_, 0] := 0;
Wedge[0, ω_] := 0;
It requires calculation of the signature of a permutation of arbitrary sortable objects, extended to have the value $0$ whenever there's a repetition. Here's a reasonably efficient implementation:
signature[p_List] :=
With[{c = First[PermutationCycles[Ordering[p]] /. Cycles -> List]},
(-1)^(Length[Flatten[c]] - Length[c])
];
signature[p_List] /; Length[Union[p]] != Length[p] := 0;
More generally, in an arbitrary algebra the product will be computed by means of a matrix of structure constants specifying the product of any two elements in a given basis. The foregoing is a programmatically simple way to provide those structure constants for $\Lambda(V)$ for any finite-dimensional vector space $V$ (note that the dimension of $\Lambda(V^n)$ is $2^n$.) For efficiency (in low dimensions, anyway) we could compute these structure constants once and for all and cache them.
The trick to computing powers in algebras with lots of zeros and other symmetries in their structure matrices is to simplify as you go, as here:
Clear[WedgePower];
WedgePower[ω_, n_] /; n >= 2 :=
Nest[Distribute[Wedge[ω, #], Plus, Wedge] &, ω, n - 1];
WedgePower[ω_, 1] := ω;
WedgePower[ω_, 0] := 1;
Distribute is implicitly doing the work of assembling pairs of basis elements to be multiplied and then collecting comparable terms, such as $dx_1\wedge dx_2 = -dx_2\wedge dx_1$, and summing their coefficients. As this is built in to Mathematica, we can expect it to be reasonably efficient.
Take, for instance, an arbitrary 2-form $\omega$ in $\Lambda(V^{10})$. It will have up to $\binom{10}{2} = 45$ nonzero coefficients; its square will have up to $\binom{10}{4} = 210$ nonzero coefficients; its cube, $210$; its fourth power, $45$; and its fifth power must be a multiple of a single form. Because you're working in an algebra of dimension $2^{10}=1024$, in principle each successive product requires $(2^{10})^2$, or over a million, calculations (although most of them will be products of zeros). Here, the bilinearity hugely reduces that number: the calculations needed to compute generic squares, cubes, fourth, and fifth powers of a 2-form are $2025$, $11475$, $20925$, and $22950$, respectively.
Trying to save time by breaking up powers into smaller groups (via the "binary method" or otherwise) can backfire. Continuing this example, computing $\omega^4$ via successive squaring requires first $2025$ operations to compute $\omega^2$ and then $44100$ to square that, a total of $46125$ products. Compare this to the value of $20925$ needed for successive wedging by $\omega$ itself: it will take more than twice as much effort.
By choosing an appropriate basis, the Liouville form can be written in a special way as $p_1 \wedge q_1 + \cdots + p_k \wedge q_k$. This reduces the calculations still further. With $k=5$ (working once more in a ten-dimensional space), for instance, the powers require only 25, 50, 50, and 25 wedge operations, respectively. This suggests yet another line of attack: before computing powers of an element of an algebra, change the basis if possible to simplify the calculation. Once again, though, how this is done will depend on the algebraic structure.
Nest[#.a&, a, 5]$=((((aa)a)a)a)a$, which is two many computations. (pun pun) ;-) $\endgroup$