all: introduce Outline and Stroke builders

This CL introduces 2 new path builders:
- Outline which takes a PathSpec to be outlined
- Stroke which takes a PathSpec and a stroke style, to stroke a path.

typically, code like this:

  var p clip.Path
  ...
  p.Outline().Add(o)

should be replaced with:

  var p clip.Path
  ...
  clip.Outline{Path: p.End()}.Op().Add(o)

similarly, stroking should be modified from:

  var p clip.Path
  ...
  p.Stroke(width, clip.StrokeStyle{...}).Add(o)

to:

  var p clip.Path
  ...
  clip.Stroke{Path: p.End(), Style: clip.StrokeStyle{Width:...}}.Op().Add(o)

here are tentative 'rf' scripts (see rsc.io/rf for more details):

  ```
  ex {
  	import "gioui.org/op";
  	import "gioui.org/op/clip";

  	var p clip.Path;
  	var o *op.Ops;

  	p.Outline().Add(o) -> clip.Outline{Path:p.End()}.Op().Add(o);
  }

  ex {
  	import "gioui.org/op";
  	import "gioui.org/op/clip";

  	var o *op.Ops;
  	var p clip.Path;
  	var sty clip.StrokeStyle;
  	var width float32;

  	p.Stroke(width, sty).Add(o) ->   \
	    clip.Stroke{                 \
		Path:p.End(),            \
		Style: clip.StrokeStyle{ \
		    Width: width,        \
	    }}.Op().Add(o);
  }
  ```

Signed-off-by: Sebastien Binet <s@sbinet.org>

op/clip/stroke.go

@@ -2,17 +2,30 @@
 
 package clip
 
-// StrokeStyle describes how a stroked path should be drawn.
-// The zero value of StrokeStyle represents bevel-joined and flat-capped
-// strokes.
+// Stroke represents a stroked path.
+type Stroke struct {
+	Path  PathSpec
+	Style StrokeStyle
+}
+
+// Op returns a clip operation representing the stroke.
+func (s Stroke) Op() Op {
+	return Op{
+		path:   s.Path,
+		stroke: s.Style,
+	}
+}
+
+// StrokeStyle describes how a path should be stroked.
 type StrokeStyle struct {
-	Cap  StrokeCap
-	Join StrokeJoin
+	Width float32 // Width of the stroked path.
 
 	// Miter is the limit to apply to a miter joint.
 	// The zero Miter disables the miter joint; setting Miter to +∞
 	// unconditionally enables the miter joint.
 	Miter float32
+	Cap   StrokeCap  // Cap describes the head or tail of a stroked path.
+	Join  StrokeJoin // Join describes how stroked paths are collated.
 }
 
 // StrokeCap describes the head or tail of a stroked path.