Replace eframe::Frame commands and WindowInfo with egui (#3564)

* Part of https://github.com/emilk/egui/issues/3556

## In short
You now almost never need to use `eframe::Frame` - instead use
`ui.input(|i| i.viewport())` for information about the current viewport
(native window), and use `ctx.send_viewport_cmd` to modify it.

## In detail

This PR removes most commands from `eframe::Frame`, and replaces them
with `ViewportCommand`.
So `frame.close()` becomes
`ctx.send_viewport_cmd(ViewportCommand::Close)`, etc.

`frame.info().window_info` is now also gone, replaced with `ui.input(|i|
i.viewport())`.

`frame.info().native_pixels_per_point` is replaced with `ui.input(|i|
i.raw.native_pixels_per_point)`.

`RawInput` now contains one `ViewportInfo` for each viewport.

Screenshots are taken with
`ctx.send_viewport_cmd(ViewportCommand::Screenshots)` and are returned
in `egui::Event` which you can check with:

``` ust
ui.input(|i| {
    for event in &i.raw.events {
        if let egui::Event::Screenshot { viewport_id, image } = event {
            // handle it here
        }
    }
});
```

### Motivation
You no longer need to pass around the `&eframe::Frame` everywhere.
This also opens the door for other integrations to use the same API of
`ViewportCommand`s.

crates/egui_demo_lib/src/demo/extra_viewport.rs

@@ -0,0 +1,72 @@
+#[derive(Default)]
+pub struct ExtraViewport {}
+
+impl super::Demo for ExtraViewport {
+    fn is_enabled(&self, ctx: &egui::Context) -> bool {
+        !ctx.embed_viewports()
+    }
+
+    fn name(&self) -> &'static str {
+        "🗖 Extra Viewport"
+    }
+
+    fn show(&mut self, ctx: &egui::Context, open: &mut bool) {
+        if !*open {
+            return;
+        }
+
+        let id = egui::Id::new(self.name());
+
+        ctx.show_viewport_immediate(
+            egui::ViewportId(id),
+            egui::ViewportBuilder::default()
+                .with_title(self.name())
+                .with_inner_size([400.0, 512.0]),
+            |ctx, class| {
+                if class == egui::ViewportClass::Embedded {
+                    // Not a real viewport
+                    egui::Window::new(self.name())
+                        .id(id)
+                        .open(open)
+                        .show(ctx, |ui| {
+                            ui.label("This egui integration does not support multiple viewports");
+                        });
+                } else {
+                    egui::CentralPanel::default().show(ctx, |ui| {
+                        ui.push_id(id, |ui| {
+                            viewport_content(ui, ctx, open);
+                        })
+                    });
+                }
+            },
+        );
+    }
+}
+
+fn viewport_content(ui: &mut egui::Ui, ctx: &egui::Context, open: &mut bool) {
+    ui.label("egui and eframe supports having multiple native windows like this, which egui calls 'viewports'.");
+
+    ui.label(format!(
+        "This viewport has id: {:?}, child of viewport {:?}",
+        ctx.viewport_id(),
+        ctx.parent_viewport_id()
+    ));
+
+    ui.label("Here you can see all the open viewports:");
+
+    egui::ScrollArea::vertical().show(ui, |ui| {
+        let viewports = ui.input(|i| i.raw.viewports.clone());
+        for (id, viewport) in viewports {
+            ui.group(|ui| {
+                ui.label(format!("viewport {id:?}"));
+                ui.push_id(id, |ui| {
+                    viewport.ui(ui);
+                });
+            });
+        }
+    });
+
+    if ui.input(|i| i.viewport().close_requested) {
+        *open = false;
+    }
+}