Unfortunately assuming works well only for simple conditions/properties.

But usually it is easy to obtain sufficient convergence conditions (as you did) and the sum can be computed using
sum(exp(a*k*Ta)*z^(-k), k=0..infinity, formal);

Edit. The convergence condition is actually  abs(exp(a*Ta)/z) < 1
but note that even assuming a<0, Ta<0, z>10  does not work.

Your  algebraic fractions al already simplified (but there are of course other possibilities, e.g. partial fractions).
For a factorization, the field K is needed.
For K=Q, the polynomials are already factorized.
If you want K=C (complete factorization) the simplest way is to find the roots with solve. E.g.

p:=(k+2)*(k^2+5)*(k^3-5*k^2+13*k-8)/(6*k*(k^2-3*k+8)):
p1,p2:=(numer,denom)(p):
R1,R2:=[solve(p1,k,explicit)],[solve(p2,k,explicit)]:
mul(k-r,r=R1)/mul(k-r,r=R2);

Actually, the solution of your ODE is

A(t) = a * exp( I * ( a^2*t + b ) ),  where  a, b are real constants.

This can be obtained with Maple writing A(t) in polar form:

restart;
ode := diff(A(t),t) - I * conjugate(A(t))*A(t)^2:
simplify(eval(ode, A(t)=R(t)*exp(I*phi(t)) )  /exp(I*phi(t)) ) assuming real:
evalc([Re,Im](%)):
dsolve(%);

restart;
a := Matrix(3, 3, [[x, y, z], [y, z, x], [z, x, y]]):
ex:= Matrix(3, 3, [[x, y, z], [y, z, x], [z, x, y]]) + B:
#eval(ex, a=A); #does not work
evalindets(ex, 'Matrix', u -> `if`(EqualEntries(u,a),A,u));
                             B + A
evalindets(ex, 'Matrix', u -> `if`(LinearAlgebra[Equal](u,a),A,u));
                             B + A

# Open Newton–Cotes (N=n-1)
ONC:=proc(n::posint)
local nodes:=[seq(k/n,k=1..n-1)], B,w,i,k,x;
B:=i -> [seq(`if`(k=i,1,0),k=1..n-1)]:
w:=[seq(int(CurveFitting:-PolynomialInterpolation(nodes,B(i),x),x=0..1),i=1..n-1)] ;
`1/(b-a)`.'c'=w,'p'=2*floor(n/2)+1
end:

ONC(5);
       `1/(b-a)` . c = [11/24, 1/24, 1/24, 11/24], p = 5

Optimization:-Minimize(
0,
{
cos(q[1])*cos(q[3])-sin(q[1])*sin(q[3])+sin(q[1])*q[2]+cos(q[1]) - 1 = 0,
sin(q[1])*cos(q[3])+cos(q[1])*sin(q[3])-cos(q[1])*q[2]+sin(q[1]) -1 = 0
},


q[1] = 2 ..  Pi, q[2] = 1 .. 1.5, q[3] = -3 .. -2

#   q[1] = 0 ..  Pi, q[2] = 0.1 .. 1.5, q[3] = -Pi/2 .. 4*Pi/3
# ,  initialpoint = [q[1]=2.0944, q[2]=1.4, q[3]=-2.7925]

);

       [0., [q[1] = 2.30431169727399, q[2] = 1.03640893001776, q[3] = -2.75622305752699]]

It seems that Maple needs help here.

solve({combine(7*cos(2*t)=7*cos(t)^2-5), t>=0, t<=2*Pi}, t, allsolutions, explicit);

With Maple the approach should be completely different, see:
https://www.mapleprimes.com/questions/204335-Can-Rotate-3d-Text-Like-This-Be-Done-In-Maple

f := (x-2)^2+1:
ff := f(x);
    (x(x)-2)^2+1

So, ff is a mathematical nonsense but syntactically correct.
Because  const(x)  simplifies to  const  we have e.g.
eval(ff, x=12);
    101

So, actually ff will work in numerical computations if eval is used.

Minimize(g, {x >= -2, x <= 2});
gives a syntax error. Use:

Minimize(g, -2..1);
          [2., Vector[column](1, [1.])]

About the piecewise stuff.

The Optimization package assumes that the objective function and constraints are twice continuously differentiable.
You cannot expect correct results if they are not so.