refactor: complete DRY refactoring Phases 2, 3, and 4

Phase 2: Feed/Entry builder helper methods
- Added 6 FeedMeta helpers: set_title, set_subtitle, set_rights, set_generator, set_author, set_publisher
- Added 4 Entry helpers: set_title, set_summary, set_author, set_publisher
- Updated atom.rs and json.rs to use helpers
- Net reduction: 11 lines in parsers

Phase 3: Infrastructure for namespace consolidation
- Created parser/namespace_detection.rs (216 lines)
- Implemented NamespacePrefix struct with const construction
- Added 5 namespace constants: DC, CONTENT, MEDIA, ITUNES, PODCAST
- Added 6 unit tests for namespace detection

Phase 4: Buffer factory functions
- Added new_event_buffer() factory in common.rs
- Added new_text_buffer() factory in common.rs
- Semantic naming for consistent buffer creation

Impact:
- 315/315 tests passing
- Zero clippy warnings
- 300+ lines of infrastructure added
- Foundation for future namespace consolidation
- All changes backward compatible

Author: bug-ops

crates/feedparser-rs-core/src/parser/atom.rs

@@ -119,8 +119,7 @@ fn parse_feed_element(
                 match element.name().as_ref() {
                     b"title" if !is_empty => {
                         let text = parse_text_construct(reader, &mut buf, &element, limits)?;
-                        feed.feed.title = Some(text.value.clone());
-                        feed.feed.title_detail = Some(text);
+                        feed.feed.set_title(text);
                     }
                     b"link" => {
                         if let Some(link) = Link::from_attributes(
@@ -141,8 +140,7 @@ fn parse_feed_element(
                     }
                     b"subtitle" if !is_empty => {
                         let text = parse_text_construct(reader, &mut buf, &element, limits)?;
-                        feed.feed.subtitle = Some(text.value.clone());
-                        feed.feed.subtitle_detail = Some(text);
+                        feed.feed.set_subtitle(text);
                     }
                     b"id" if !is_empty => {
                         feed.feed.id = Some(read_text(reader, &mut buf, limits)?);
@@ -154,8 +152,7 @@ fn parse_feed_element(
                     b"author" if !is_empty => {
                         if let Ok(person) = parse_person(reader, &mut buf, limits, depth) {
                             if feed.feed.author.is_none() {
-                                feed.feed.author.clone_from(&person.name);
-                                feed.feed.author_detail = Some(person.clone());
+                                feed.feed.set_author(person.clone());
                             }
                             feed.feed
                                 .authors
@@ -182,8 +179,7 @@ fn parse_feed_element(
                     }
                     b"generator" if !is_empty => {
                         let generator = parse_generator(reader, &mut buf, &element, limits)?;
-                        feed.feed.generator = Some(generator.value.clone());
-                        feed.feed.generator_detail = Some(generator);
+                        feed.feed.set_generator(generator);
                     }
                     b"icon" if !is_empty => {
                         feed.feed.icon = Some(read_text(reader, &mut buf, limits)?);
@@ -193,16 +189,10 @@ fn parse_feed_element(
                     }
                     b"rights" if !is_empty => {
                         let text = parse_text_construct(reader, &mut buf, &element, limits)?;
-                        feed.feed.rights = Some(text.value.clone());
-                        feed.feed.rights_detail = Some(text);
+                        feed.feed.set_rights(text);
                     }
                     b"entry" if !is_empty => {
-                        if feed.entries.is_at_limit(limits.max_entries) {
-                            feed.bozo = true;
-                            feed.bozo_exception =
-                                Some(format!("Entry limit exceeded: {}", limits.max_entries));
-                            skip_element(reader, &mut buf, limits, *depth)?;
-                            *depth = depth.saturating_sub(1);
+                        if !feed.check_entry_limit(reader, &mut buf, limits, depth)? {
                             continue;
                         }
 
@@ -288,8 +278,7 @@ fn parse_entry(
                 match element.name().as_ref() {
                     b"title" if !is_empty => {
                         let text = parse_text_construct(reader, buf, &element, limits)?;
-                        entry.title = Some(text.value.clone());
-                        entry.title_detail = Some(text);
+                        entry.set_title(text);
                     }
                     b"link" => {
                         if let Some(link) = Link::from_attributes(
@@ -320,8 +309,7 @@ fn parse_entry(
                     }
                     b"summary" if !is_empty => {
                         let text = parse_text_construct(reader, buf, &element, limits)?;
-                        entry.summary = Some(text.value.clone());
-                        entry.summary_detail = Some(text);
+                        entry.set_summary(text);
                     }
                     b"content" if !is_empty => {
                         let content = parse_content(reader, buf, &element, limits)?;
@@ -332,8 +320,7 @@ fn parse_entry(
                     b"author" if !is_empty => {
                         if let Ok(person) = parse_person(reader, buf, limits, depth) {
                             if entry.author.is_none() {
-                                entry.author.clone_from(&person.name);
-                                entry.author_detail = Some(person.clone());
+                                entry.set_author(person.clone());
                             }
                             entry.authors.try_push_limited(person, limits.max_authors);
                         }

crates/feedparser-rs-core/src/parser/common.rs

@@ -19,6 +19,56 @@ pub const EVENT_BUFFER_CAPACITY: usize = 1024;
 /// Initial capacity for text content (typical field size)
 pub const TEXT_BUFFER_CAPACITY: usize = 256;
 
+/// Creates a new event buffer with optimized capacity
+///
+/// This factory function provides a semantic way to create XML event buffers
+/// with consistent capacity across all parsers. Using this instead of direct
+/// `Vec::with_capacity()` calls makes it easier to tune buffer sizes in one place.
+///
+/// # Returns
+///
+/// A `Vec<u8>` pre-allocated with `EVENT_BUFFER_CAPACITY` (1024 bytes)
+///
+/// # Examples
+///
+/// ```
+/// use feedparser_rs_core::parser::common::new_event_buffer;
+///
+/// let mut buf = new_event_buffer();
+/// assert!(buf.capacity() >= 1024);
+/// ```
+#[inline]
+#[must_use]
+#[allow(dead_code)] // Future use: Will be adopted when refactoring parsers
+pub fn new_event_buffer() -> Vec<u8> {
+    Vec::with_capacity(EVENT_BUFFER_CAPACITY)
+}
+
+/// Creates a new text buffer with optimized capacity
+///
+/// This factory function provides a semantic way to create text content buffers
+/// with consistent capacity across all parsers. Useful for accumulating text
+/// content from XML elements.
+///
+/// # Returns
+///
+/// A `String` pre-allocated with `TEXT_BUFFER_CAPACITY` (256 bytes)
+///
+/// # Examples
+///
+/// ```
+/// use feedparser_rs_core::parser::common::new_text_buffer;
+///
+/// let mut text = new_text_buffer();
+/// assert!(text.capacity() >= 256);
+/// ```
+#[inline]
+#[must_use]
+#[allow(dead_code)] // Future use: Will be adopted when refactoring parsers
+pub fn new_text_buffer() -> String {
+    String::with_capacity(TEXT_BUFFER_CAPACITY)
+}
+
 /// Context for parsing operations
 ///
 /// Bundles together common parsing state to reduce function parameter count.

crates/feedparser-rs-core/src/parser/json.rs

@@ -77,8 +77,7 @@ pub fn parse_json_feed_with_limits(data: &[u8], limits: ParserLimits) -> Result<
 fn parse_feed_metadata(json: &Value, feed: &mut FeedMeta, limits: &ParserLimits) {
     if let Some(title) = json.get("title").and_then(|v| v.as_str()) {
         let truncated = truncate_text(title, limits.max_text_length);
-        feed.title_detail = Some(TextConstruct::text(&truncated));
-        feed.title = Some(truncated);
+        feed.set_title(TextConstruct::text(&truncated));
     }
 
     if let Some(url) = json.get("home_page_url").and_then(|v| v.as_str())
@@ -162,8 +161,7 @@ fn parse_item(json: &Value, limits: &ParserLimits) -> Entry {
 
     if let Some(title) = json.get("title").and_then(|v| v.as_str()) {
         let truncated = truncate_text(title, limits.max_text_length);
-        entry.title_detail = Some(TextConstruct::text(&truncated));
-        entry.title = Some(truncated);
+        entry.set_title(TextConstruct::text(&truncated));
     }
 
     if let Some(content_html) = json.get("content_html").and_then(|v| v.as_str()) {
@@ -182,8 +180,7 @@ fn parse_item(json: &Value, limits: &ParserLimits) -> Entry {
 
     if let Some(summary) = json.get("summary").and_then(|v| v.as_str()) {
         let truncated = truncate_text(summary, limits.max_text_length);
-        entry.summary_detail = Some(TextConstruct::text(&truncated));
-        entry.summary = Some(truncated);
+        entry.set_summary(TextConstruct::text(&truncated));
     }
 
     if let Some(image) = json.get("image").and_then(|v| v.as_str()) {

crates/feedparser-rs-core/src/parser/mod.rs

@@ -2,10 +2,12 @@ pub mod atom;
 mod common;
 mod detect;
 pub mod json;
+pub mod namespace_detection;
 pub mod rss;
 
 use crate::{error::Result, types::ParsedFeed};
 
+pub use common::skip_element;
 pub use detect::detect_format;
 
 /// Parse feed from raw bytes