add 60k track fake data generator

CHANGELOG.md

···
   - #docs wrote installation instructions in README.md
   - #tooling tested cargo install --path . pipeline
   - #app tested 10k item scrolling (smooth in release mode)
+  - #app made list full width (removed container padding, added width::Fill to column)
+  - #app added table-like styling (borders between items, padding on each row)
+  - #app fixed double border issue (using horizontal_rule between items for clean separation)
+  - #data created Track struct with realistic fields (artist, title, radio, genre, year, url)
+  - #data generated 60k fake tracks with 30 artist names, 16 radio stations, 15 genres
+  - #structure separated concerns: src/track.rs for data, src/main.rs for UI
+  - #perf verified GPU scrolling handles 60k items instantly

src/main.rs

···
-use iced::widget::{column, container, scrollable, text};
-use iced::Length;
+mod track;
+
+use iced::widget::{column, container, horizontal_rule, scrollable, text};
+use iced::{Color, Length, Theme};
+use track::Track;
 
 fn main() -> iced::Result {
-    iced::run("r4 - 10k items", update, view)
+    iced::run("r4 - 60k tracks", update, view)
 }
 
 struct State {
-    items: Vec<String>,
+    tracks: Vec<Track>,
 }
 
 impl Default for State {
     fn default() -> Self {
         Self {
-            items: (0..10_000)
-                .map(|i| format!("item #{:05} - dummy data for performance testing", i))
-                .collect(),
+            tracks: Track::generate_fake(60_000),
         }
     }
 }
···
 fn update(_state: &mut State, _message: Message) {}
 
 fn view(state: &State) -> iced::Element<Message> {
-    let item_list = state.items.iter().fold(
-        column![].spacing(4),
-        |col, item| col.push(text(item))
-    );
+    let item_list = state.tracks.iter().enumerate().fold(
+        column![].spacing(0).width(Length::Fill),
+        |col, (i, track)| {
+            let track_info = format!(
+                "{} - {} [{}] ({})",
+                track.artist, track.title, track.genre, track.year
+            );
+            let item_container = container(text(track_info))
+                .padding(12)
+                .width(Length::Fill);
 
-    let content = scrollable(
-        container(item_list)
-            .padding(20)
+            let mut col = col.push(item_container);
+
+            if i < state.tracks.len() - 1 {
+                col = col.push(
+                    horizontal_rule(1)
+                        .style(|_theme: &Theme| {
+                            iced::widget::rule::Style {
+                                color: Color::from_rgb(0.2, 0.2, 0.2),
+                                width: 1,
+                                radius: 0.0.into(),
+                                fill_mode: iced::widget::rule::FillMode::Full,
+                            }
+                        })
+                );
+            }
+
+            col
+        }
     );
+
+    let content = scrollable(item_list);
 
     container(content)
         .width(Length::Fill)

src/track.rs

···
+#[derive(Debug, Clone)]
+pub struct Track {
+    pub id: u32,
+    pub title: String,
+    pub artist: String,
+    pub radio: String,
+    pub genre: String,
+    pub year: u16,
+    pub url: String,
+}
+
+impl Track {
+    pub fn generate_fake(count: usize) -> Vec<Track> {
+        let genres = [
+            "rock", "electronic", "jazz", "ambient", "techno",
+            "indie", "metal", "pop", "classical", "hip-hop",
+            "folk", "blues", "punk", "soul", "disco"
+        ];
+
+        let radios = [
+            "Midnight Frequencies", "Coastal Waves", "Desert Transit",
+            "Urban Echo", "Forest Sessions", "Neon Nights",
+            "Analog Dreams", "Digital Shores", "Mountain Reverb",
+            "Chrome Signals", "Velvet Underground FM", "Crystal Static",
+            "Concrete Jungle Radio", "Aurora Borealis Broadcast",
+            "Tropical Frequency", "Arctic Transmissions"
+        ];
+
+        let artists = [
+            "Luna Vesper", "The Midnight Architects", "Neon Cascades",
+            "Velvet Machinery", "Solar Flares", "Echo Chamber Ensemble",
+            "Digital Nomads", "Analog Hearts", "The Reverb Society",
+            "Crystal Method Collective", "Urban Landscapes", "Cosmic Debris",
+            "Twilight Operators", "The Static Kings", "Wavelength Warriors",
+            "Frequency Modulation", "Bass & Treble", "The Delay Pedals",
+            "Vintage Circuits", "Modern Fossils", "The Loop Collective",
+            "Synth & Soul", "Tape Deck Memories", "The Algorithm",
+            "Human After All", "Channel Zero", "The Bandwidth",
+            "Stereo Phantoms", "Mono Myths", "The Decibels"
+        ];
+
+        (0..count).map(|i| Track {
+            id: i as u32,
+            title: format!("Track #{:05}", i),
+            artist: artists[i % artists.len()].to_string(),
+            radio: radios[i % radios.len()].to_string(),
+            genre: genres[i % genres.len()].to_string(),
+            year: 1990 + (i % 35) as u16,
+            url: format!("https://youtube.com/watch?v=fake{}", i),
+        }).collect()
+    }
+}

todo.txt

···
 todo
 ====
 
-next - hello world
-------------------
-[ ] remove r4/ folder (dioxus prototype)
-[ ] cargo init --name r4
-[ ] add iced dependency to Cargo.toml
-[ ] write minimal main.rs (counter example from docs)
-[ ] cargo run to test
-[ ] verify window opens and counter works
-
 
 backlog
 -------
+- make the list full width and responsive?
 [ ] fetch radio4000 data structure
 [ ] design data model for radios/tracks
 [ ] display list of radios