This solution is longer but seems to be easier to follow.

Area:=proc(rel::set(relation))
local x,y, xy:=indets(rel,name),S, ff, u;
if nops(xy)<>2 then error "Two vars only!" fi;
x,y:=xy[];
S:=remove(hastype, [solve(rel)],`=`);
ff:=proc(rel)
local t,ux,uy,x1:=NULL,x2:=NULL,y1:=NULL,y2:=NULL, r:=rel;
ux:=select(t -> (lhs(t)=x and not has(rhs(t),y)) or (rhs(t)=x and not has(lhs(t),y)), rel);
uy:=select(t -> (lhs(t)=y and not has(rhs(t),x)) or (rhs(t)=y and not has(lhs(t),x)), rel);
if nops(uy)=2 and nops(ux)=0 then 
   ux,uy:=uy,ux; ux:=subs([x=y,y=x],ux); uy:=subs([x=y,y=x],uy); r:=subs([x=y,y=x],rel) fi;
if nops(ux)=2 and nops(uy)=0 then
   uy:=r minus ux;  if nops(uy)<>2 then error "Unusual solve solution" fi; 
   if rhs(ux[1])=x then x1:=lhs(ux[1]) fi;
   if rhs(ux[2])=x then x1:=lhs(ux[2]) fi;
   if lhs(ux[1])=x then x2:=rhs(ux[1]) fi;
   if lhs(ux[2])=x then x2:=rhs(ux[2]) fi;
   if rhs(uy[1])=y then y1:=lhs(uy[1]) fi;
   if rhs(uy[2])=y then y1:=lhs(uy[2]) fi;
   if lhs(uy[1])=y then y2:=rhs(uy[1]) fi;
   if lhs(uy[2])=y then y2:=rhs(uy[2]) fi;
   if nops([x1,x2,y1,y2])<4 then error "xk or yk null" fi;
   return simplify(int(1,y=y1..y2,x=x1..x2));
else error "Unable to compute!";
fi;   
end:
add(ff(u), u=S);
end:

R:={abs(abs(x-y)-abs(x+y)) >= 2*y-x+1, (x+1)^2+(y+1)^2 <= 2}:
Area(R);

radnormal(%);

evalf(%);
    4.419820813

[I could not upload the worksheet.]

It is a typesetting bug.

- If you execute
eval(%);

the strange term disappears.

- If you set
interface(typesetting=standard);
and re-execute, ==>

Error, (in print/diff) unable to display this derivative. Would you please report the problem to support@maplesoft.com

Yes, it's a bug.

I have renamed the variables (see the attach) and I wrote the system in a matrix form.

read "EQX.txt":
V:=[indets(EQX)[]]:nops(V);
                              1020
with(LinearAlgebra):
A,b:=LinearAlgebra:-GenerateMatrix( EQX, V ):
Rank(A);
                              326

Rank(<A|b>);
                              327

So, the system is incompatible (normally, Maple cannot be wrong for this computation, but we never know ...).

EQX.txt

The algorithm is simple.

Let {[x_k, u_k] :  k=1..n} union {[x_k, v_k] :  k=1..n}
be the extreme points given by convexhull.
Here u_k <= v_k, equality being possible.
(Obviously there cannot be 3 points with the same abscissa)
Also x_k are all distinct; one may suppose x_1 < ... < x_n
(after a sort command).

1. Compute min {u_k : k=1..n} = u_p
If p is not unique, take the largest one.

2. The wanted points are {[x_k, u_k] : k=p..n}.

You cannot use infolevel because the algorithms have changed. It seems that using another method (see ?Basis) does not help.
But the problem can be solved:

F:=[f[1],f[2],f[3]]:
gb:=Basis(F,plex(c,x[1],x[2])):  #  gbasis command is deprecated

factor~(gb);

From the last polynomial, it is clear that for c=3 we do not have a reduced basis.
So, if c is seen as a parameter, c=3 must be considered separately.

Y:=solve(sqrt(x^2+y^2)=(3-x)/2, y):
 X:=solve(Y[1]);
                           X := -3, 1
plots:-shadebetween(sqrt(x^2+y^2), (3-x)/2, x=X[1]..X[2], y=Y[1]..Y[2]);

Matrix(3, (i,j) -> Gradient~(V)[i][j]);

It will also work for non-cartesian coordinates.

I have included a transform for polylog not used by maple (it seems).

mypolylog:=proc(n,z)
local x:=argument(z)/(2*Pi);
if is(abs(z)<>1  or (not type(n,posint)) or z=1 or x<0) then return polylog(n,z) fi;
-(-1)^n*polylog(n,1/z) - (2*Pi*I)^n/n!*bernoulli(n,x)
end:

s:=sum((sin(k)/k)^7, k = 1 .. infinity);

r:=simplify(eval(%, polylog=mypolylog));

evalf([s,r]); # check

This is in the realm of Numerical Approximation, an important mathematical branch.
In Maple see ?numapprox
It is usually needed a careful study of the function to be approximated and an estimation of the error (absolute/relative).

I see two solutions:
1. Revise the automatic simplication for INTERVALs
2. Overload the `*` operator by the user (for the second issue).

To compute evalr(x*x) for
x:=INTERVAL(-1 .. 1);
one may use the ad-hoc
evalr('evalr'(x)*x);

BooleanSimplify returns a sum of products [sum=%or, product=%and].
Your expression is far from having a single term i.e. a product only. It is huge.
In order to obtain something you will have to fix some variables.

Download boolean.mw

Download projectile.mw