Fix deserialization of empty structs and tuples in untagged enums

[Mingun]

This PR is logical continuation of #2788 and #2804, for untagged enums. While I working on it I found a bug that was fixed.

This PR moves all tests which tests top-level untagged enums (those which is defined using #[serde(untagged)] attribute) into a dedicated file and adds tests to cover missing methods of ContentRefDeserializer that used for deserialization. Flatten tests where untagged enum is flattened into structure I consider foremost as flatten tests, so they left untouched.

Each method in ContentRefDeserializer and linked structs was marked with a comment that shows which test(s) cover it. After this work a bug was catched:

#[derive(Deserialize)]
#[serde(untagged)]
enum Untagged {
    Newtype(ExternallyTagged),
}

#[derive(Deserialize)]
enum ExternallyTagged {
    EmptyTuple(),
    EmptyStruct {},
}

The Untagged type could not be deserialized because SeqRefDeserializer (which is used for deserialization) has a special code to handle empty sequences which was not covered and never worked:

serde/serde/src/private/de.rs

Lines 2228 to 2244 in 1a9ffdb

	fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
	where
	V: de::Visitor<'de>,
	{
	let len = self.iter.len();
	if len == 0 {
	visitor.visit_unit()
	} else {
	let ret = tri!(visitor.visit_seq(&mut self));
	let remaining = self.iter.len();
	if remaining == 0 {
	Ok(ret)
	} else {
	Err(de::Error::invalid_length(len, &"fewer elements in array"))
	}
	}
	}

The new tests shows that it is impossible to create such a type that would accept visit_unit() in line 2234. The condition len == 0 assumes that type would be able to deserialized from unit, but:

1. struct variants was never able to deserialize from it (they expect only visit_map or visit_seq)
2. tuple variants even with zero fields expect visit_seq only. The suggestion to accept visit_unit instead was rejected in Fix incorrect representation of tuples with skipped fields #2520

After appling the fix the MapRefDeserializer and SeqRefDeserializer no longer used so they are removed. Actually, because direct deserialization of maps and sequences from the ContentRefDeserializer uses value::MapDeserializer, that is just unifies the behaviour:

serde/serde/src/private/de.rs

Lines 1938 to 1946 in 1a9ffdb

	fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
	V: Visitor<'de>,
	{
	match *self.content {
	Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
	_ => Err(self.invalid_type(&visitor)),
	}
	}

serde/serde/src/private/de.rs

Lines 1967 to 1975 in 1a9ffdb

	fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
	V: Visitor<'de>,
	{
	match *self.content {
	Content::Map(ref v) => visit_content_map_ref(v, visitor),
	_ => Err(self.invalid_type(&visitor)),
	}
	}

value::MapDeserializer and value::SeqDeserializer are used:

serde/serde/src/private/de.rs

Lines 1685 to 1718 in 1a9ffdb

	fn visit_content_seq_ref<'a, 'de, V, E>(
	content: &'a [Content<'de>],
	visitor: V,
	) -> Result<V::Value, E>
	where
	V: Visitor<'de>,
	E: de::Error,
	{
	let seq = content.iter().map(ContentRefDeserializer::new);
	let mut seq_visitor = SeqDeserializer::new(seq);
	let value = tri!(visitor.visit_seq(&mut seq_visitor));
	tri!(seq_visitor.end());
	Ok(value)
	}
	fn visit_content_map_ref<'a, 'de, V, E>(
	content: &'a [(Content<'de>, Content<'de>)],
	visitor: V,
	) -> Result<V::Value, E>
	where
	V: Visitor<'de>,
	E: de::Error,
	{
	let map = content.iter().map(|(k, v)| {
	(
	ContentRefDeserializer::new(k),
	ContentRefDeserializer::new(v),
	)
	});
	let mut map_visitor = MapDeserializer::new(map);
	let value = tri!(visitor.visit_map(&mut map_visitor));
	tri!(map_visitor.end());
	Ok(value)
	}

[Mingun]

@dtolnay , @oli-obk , can you look at this bugfix?

[dtolnay]

Thanks!