This is only done in C++, the binding code still constructs a new node.

Fixes drawing with final transform, introduces color property per each node.

Added a bunch of other methods to collect polygons and polylines.

Greatly simplifies boolean operations, `is_hole` renamed to `is_inner`
to denote hierarchical representation of nodes, and not necessarily
geometrical meaning.

Some of these may still make sense, but can be reimplemented later.

Drawing is per node now, but mostly parent is responsible.
Outlines from operations such as difference can be implemented
in canvas editor plugin instead.

Allows to edit points.

See godotengine/godot#16466.

The warning suggests that such nodes should be converted to `PolyNode2D` instead, this will be implemented.

One issue still persists: I haven't found a way to move `PolyCircle2D` in the editor unless you use the move tool explicitly.

`replace_node` keeps properties, but that also overrides our previously set points too...

They do not generate points, which caused wrong execution path.

Also modify tooltip message.

This ensures that the outlines of the parent node shall be defined
at all times, unless `OP_NONE` is set explicitly, which would also allow
to draw different texture for such a node.

Makes it consistent with `RectangleShape2D` in Godot.

Makes it consistent with `RectangleShape2D` in Godot.

Doesn't work well for closed outlines where drawing is done
with triangle array in Godot 3.2, see discussion in:

godotengine/godot#10645

Seems to work better for line drawing.

Works by decomposing `PolyNode2D` children into shapes such as
triangles, convex polygons etc.

This does not yet add collision stuff, this will be implemented in
a node derived from `PolyMesh2D`.

Extends `PolyMesh2D`, uses `PolyNode2D`s to define its shape similarly.

The class is analogous to `CollisionPolygon2D`, except that the build
mode is defined in parent mesh class, and the shape is edited through
`PolyNode2D`s at all times, this makes it quite flexible and reusable.

For consistency and ease of discoverty along with Godot's
`CollisionShape2D`. Cannot rename this to `PolyCollisionPolygon2D`,
as `Poly*` already suggests so.

By design, derived classes can override this.

This may be confusing with CSG nodes in 3D, as mesh is used there
for one of the CSG shape generators.

We don't use `Shape` terminology here in `PolyNode2D` like for
`PolyCircle2D` or `PolyRectangle2D` as it's not necessarily about boolean
operators, but also representing an hierarchy of nested outlines, so
Goost reserves `Shape` terminology to lean closer to collision shapes.

Convexivity should not be important here, it's about what constitutes the shape.

No `PolyShape2D` icon is added, because it's only used as
a base for implementing other classes, as the case with
`PolyCollisionShape2D`.

"Path" may be misleading because there's `Path/Path2D` nodes...

Had to fix poly tests as well.