Explicit text caching

[hecrj]

This PR enables explicit text caching at the widget level by introducing a new Paragraph associated type to core::text::Renderer.

Until now, widgets could draw text indirectly by issuing a Renderer::fill_text command. The Renderer then took care of layout and caching behind the scenes. This caused a bunch of challenges; specifically, hashing, aliasing, and cache invalidation.

With caching, memory management also becomes tricky and less intuitive. If a specific frame needs to measure a lot of intermediate text, then the internal map used for caching may allocate a bunch of memory unnecessarily, as most of the entries may not be reused.

After this PR, a widget can choose to create and manage a Paragraph. A Paragraph represents a bunch of text that has been laid out and is ready to be rendered at minimum cost. Since it's already shaped and laid out, its bounds are already computed and, therefore, measuring it has no cost. Internally, a Paragraph is just a thin wrapper of a cosmic_text::Buffer.

The tricky part is that a Paragraph needs to be managed. Widgets are responsible to keep it in sync manually with their state. This normally consists in calling Renderer::update_paragraph during Widget::layout, which will try to reconcile any differences as efficiently as possible (e.g. a change in paragraph bounds can skip shaping altogether!).

Text, TextInput, Checkbox, Radio, and Toggler use the new managed approach, which I expect should improve performance and memory usage in most cases.

There are some cases where caching is superior, however. Specifically, given that paragraphs are stored in the widget state tree, a small change in the widget tree can cause a bunch of text to be relaid out (potentially all of it!). The cached approach doesn't have this problem because caching happens on a per-frame basis, independently of the widget tree.

However, I have some ideas to improve the diffing strategy to handle most common cases more efficiently. And it's also important to note that a text::Renderer does still support the cached strategy, so we could eventually give users some control over the strategy used.

This also sets up some of the foundations necessary for multi-line text editing, as it is now possible to easily query and manipulate text buffers without recalculating (nor hashing) everything.

Related changes

Besides the Paragraph additions, there have been some other changes here and there:

• A new layout::next_to_each_other helper. No more awkwardly using Row inside widget code!
• Widget::layout now takes a mutable widget::Tree. This is useful to cache layout data or update managed paragraphs, for instance.
• All text sizes are represented by the Pixels type now.
• core::Text does no longer have color. Instead, the color is provided to the Renderer when drawing.
• The bounds in core::Text are now a Size instead of a Rectangle. The final position of the Text must be provided when drawing.

TODOs

• Rename Paragraph. Technically, Paragraph isn't the right name because the idea it currently represents can contain multiple paragraphs. I'm considering renaming it to something different like text::Allocation or text::Buffer. I can't find a more descriptive name, so Paragraph it is!
• Implement Paragraph drawing in iced_tiny_skia.
• Implement Icon support for TextInput.
• Invalidate paragraphs when a new font is loaded.

[hecrj]

Hey! I wrote some docs for once!